Version 11 released. Read https://github.com/kataras/iris/blob/master/HISTORY.md#su-21-october-2018--v1100

Former-commit-id: fe6305deed00e170bf4d39a12c0644fe686e0a24

.travis.yml

@@ -3,13 +3,14 @@ os:
   - linux
   - osx
 go:
-  - "go1.9"
-  - "go1.10"
+  - 1.9.x
+  - 1.10.x
+  - 1.11.x
 go_import_path: github.com/kataras/iris
 # we disable test caching via GOCACHE=off
-env:
-  global:
-    - GOCACHE=off
+# env:
+#  global:
+#    - GOCACHE=off
 install:
   - go get ./... # for iris-contrib/httpexpect, kataras/golog
 script:

Dockerfile

@@ -1,5 +0,0 @@
-FROM irisgo/cloud-native-go:latest
-
-ENV APPSOURCES /go/src/github.com/iris-contrib/cloud-native-go
-
-RUN ${APPSOURCES}/cloud-native-go

Dockerfile.build

@@ -1,12 +0,0 @@
-FROM golang:1.9.3-alpine
-
-RUN apk update && apk upgrade && apk add --no-cache bash git
-RUN go get github.com/iris-contrib/cloud-native-go
-
-ENV SOURCES /go/src/github.com/iris-contrib/cloud-native-go
-# COPY . ${SOURCES}
-
-RUN cd ${SOURCES} $$ CGO_ENABLED=0 go build
-
-ENTRYPOINT cloud-native-go
-EXPOSE 8080

FAQ.md

@@ -30,7 +30,7 @@ More than 100 practical examples, tutorials and articles at:
 
 - https://github.com/kataras/iris/tree/master/_examples
 - https://github.com/iris-contrib/examples
-- https://iris-go.com/v10/recipe
+- https://iris-go.com/v11/recipe
 - https://docs.iris-go.com (in-progress)
 - https://godoc.org/github.com/kataras/iris
 

Gopkg.lock

@@ -115,12 +115,6 @@
   packages = [".","terminal"]
   revision = "825e39f34365e7db2c9fbc3692c16220e3bd7418"
 
-[[projects]]
-  branch = "v2"
-  name = "github.com/kataras/survey"
-  packages = [".","terminal","core"]
-  revision = "00934ae069eda15df26fa427ac393e67e239380c"
-
 [[projects]]
   name = "github.com/klauspost/compress"
   packages = ["flate","gzip"]
@@ -277,6 +271,24 @@
   packages = ["."]
   revision = "aad8439df3bf67adb025382ee2e5f46a72fc9456"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/dgraph-io/badger"
+  packages = ["."]
+  revision = "99233d725dbdd26d156c61b2f42ae1671b794656"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/etcd-io/bbolt"
+  packages = ["."]
+  revision = "acbc2c426a444a65e0cbfdcbb3573857bf18b465"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/gomodule/redigo"
+  packages = ["internal","redis"]
+  revision = "2cd21d9966bf7ff9ae091419744f0b3fb0fecace"
+
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1

Gopkg.toml

@@ -42,10 +42,6 @@
   branch = "master"
   name = "github.com/kataras/golog"
 
-[[constraint]]
-  branch = "v2"
-  name = "github.com/kataras/survey"
-
 [[constraint]]
   name = "github.com/klauspost/compress"
   version = "1.2.1"
@@ -80,4 +76,16 @@
 
 [[constraint]]
   branch = "master"
-  name = "github.com/Shopify/goreferrer"
+  name = "github.com/Shopify/goreferrer"
+
+[[constraint]]
+  name = "github.com/dgraph-io/badger"
+  version = "1.5.4"
+
+[[constraint]]
+  name = "github.com/etcd-io/bbolt"
+  version = "1.3.1-etcd.7"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/gomodule/redigo"

HISTORY.md

@@ -17,6 +17,174 @@ Developers are not forced to upgrade if they don't really need it. Upgrade whene
 
 **How to upgrade**: Open your command-line and execute this command: `go get -u github.com/kataras/iris` or let the automatic updater do that for you.
 
+# Su, 21 October 2018 | v11.0.0
+
+For the craziest of us, click [here](https://github.com/kataras/iris/compare/v10.7.0...v11) 🔥 to find out the commits and the code changes since our previous release.
+
+## Breaking changes
+
+- Remove the "Configurator" `WithoutVersionChecker` and the configuration field `DisableVersionChecker`
+- `:int` parameter type **can accept negative numbers now**.
+- `app.Macros().String/Int/Uint64/Path...RegisterFunc` should be replaced to: `app.Macros().Get("string" or "int" or "uint64" or "path" when "path" is the ":path" parameter type).RegisterFunc`, because you can now add custom macros and parameter types as well, see [here](_examples/routing/macros).
+- `RegisterFunc("min", func(paramValue string) bool {...})` should be replaced to `RegisterFunc("min", func(paramValue <T>) bool {...})`, the `paramValue` argument is now stored in the exact type the macro's type evaluator inits it, i.e `uint64` or `int` and so on, therefore you don't have to convert the parameter value each time (this should make your handlers with macro functions activated even faster now) 
+- The `Context#ReadForm` will no longer return an error if it has no value to read from the request, we let those checks to the caller and validators as requested at: https://github.com/kataras/iris/issues/1095 by [@haritsfahreza](https://github.com/haritsfahreza)
+
+## Routing
+
+I wrote a [new router implementation](https://github.com/kataras/muxie#philosophy) for our Iris internal(low-level) routing mechanism, it is good to know that this was the second time we have updated the router internals without a single breaking change after the v6, thanks to the very well-writen and designed-first code we have for the high-level path syntax component called [macro interpreter](macro/interpreter).
+
+The new router supports things like **closest wildcard resolution**.
+
+> If the name doesn't sound good to you it is because I named that feature myself, I don't know any other framework or router that supports a thing like that so be gentle:)
+
+Previously you couldn't register routes like: `/{myparam:path}` and `/static` and `/{myparam:string}` and `/{myparam:string}/static` and `/static/{myparam:string}` all in one path prefix without a "decision handler". And generally if you had a wildcard it was possible to add (a single) static part and (a single) named parameter but not without performance cost and limits, why only one? (one is better than nothing: look the Iris' alternatives) We struggle to overcome our own selves, now you **can definitely do it without a bit of performance cost**, and surely we hand't imagine the wildcard to **catch all if nothing else found** without huge routing performance cost, the wildcard(`:path`) meant ONLY: "accept one or more path segments and put them into the declared parameter" so if you had register a dynamic single-path-segment named parameter like `:string, :int, :uint, :alphabetical...` in between those path segments it wouldn't work. The **closest wildcard resolution** offers you the opportunity to design your APIs even better via custom handlers and error handlers like `404 not found` to path prefixes for your API's groups, now you can do it without any custom code for path resolution inside a "decision handler" or a middleware.
+
+Code worths 1000 words, now it is possible to define your routes like this without any issues:
+
+```go
+package main
+
+import (
+    "github.com/kataras/iris"
+    "github.com/kataras/iris/context"
+)
+
+func main() {
+    app := iris.New()
+
+    // matches everyhing if nothing else found,
+    // so you can use it for custom 404 root-level/main pages!
+    app.Get("/{p:path}", func(ctx context.Context) {
+        path := ctx.Params().Get("p")
+        // gives the path without the first "/".
+        ctx.Writef("Site Custom 404 Error Message\nPage of: '%s' not found", path)
+    })
+
+    app.Get("/", indexHandler)
+
+    // request: http://localhost:8080/profile
+    // response: "Profile Index"
+    app.Get("/profile", func(ctx context.Context) {
+        ctx.Writef("Profile Index")
+    })
+
+    // request: http://localhost:8080/profile/kataras
+    // response: "Profile of username: 'kataras'"
+    app.Get("/profile/{username}", func(ctx context.Context) {
+        username := ctx.Params().Get("username")
+        ctx.Writef("Profile of username: '%s'", username)
+    })
+
+    // request: http://localhost:8080/profile/settings
+    // response: "Profile personal settings"
+    app.Get("/profile/settings", func(ctx context.Context) {
+        ctx.Writef("Profile personal settings")
+    })
+
+    // request: http://localhost:8080/profile/settings/security
+    // response: "Profile personal security settings"
+    app.Get("/profile/settings/security", func(ctx context.Context) {
+        ctx.Writef("Profile personal security settings")
+    })
+
+    // matches everyhing /profile/*somethng_here*
+    // if no other route matches the path semgnet after the
+    // /profile or /profile/
+    //
+    // So, you can use it for custom 404 profile pages
+    // side-by-side to your root wildcard without issues!
+    // For example:
+    // request: http://localhost:8080/profile/kataras/what
+    // response:
+    // Profile Page Custom 404 Error Message
+    // Profile Page of: 'kataras/what' was unable to be found
+    app.Get("/profile/{p:path}", func(ctx context.Context) {
+        path := ctx.Params().Get("p")
+        ctx.Writef("Profile Page Custom 404 Error Message\nProfile Page of: '%s' not found", path)
+    })
+
+    app.Run(iris.Addr(":8080"))
+}
+
+func indexHandler(ctx context.Context) {
+    ctx.HTML("This is the <strong>index page</strong>")
+}
+
+``` 
+
+The `github.com/kataras/iris/core/router.AllMethods` is now a variable that can be altered by end-developers, so things like `app.Any` can register to custom methods as well, as requested at: https://github.com/kataras/iris/issues/1102. For example, import that package and do `router.AllMethods = append(router.AllMethods, "LINK")` in your `main` or `init` function.
+
+The old `github.com/kataras/iris/core/router/macro` package was moved to `guthub.com/kataras/iris/macro` to allow end-developers to add custom parameter types and macros, it supports all go standard types by default as you will see below.
+
+- `:int` parameter type as an alias to the old `:int` which can accept any numeric path segment now, both negative and positive numbers
+- Add `:int8` parameter type and `ctx.Params().GetInt8`
+- Add `:int16` parameter type and `ctx.Params().GetInt16`
+- Add `:int32` parameter type and `ctx.Params().GetInt32`
+- Add `:int64` parameter type and `ctx.Params().GetInt64`
+- Add `:uint` parameter type and `ctx.Params().GetUint`
+- Add `:uint8` parameter type and `ctx.Params().GetUint8`
+- Add `:uint16` parameter type and `ctx.Params().GetUint16`
+- Add `:uint32` parameter type and `ctx.Params().GetUint32`
+- Add `:uint64` parameter type and `ctx.Params().GetUint64`
+- Add alias `:bool` for the `:boolean` parameter type
+
+Here is the full list of the built'n parameter types that we support now, including their validations/path segment rules.
+
+| Param Type | Go Type | Validation | Retrieve Helper |
+| -----------------|------|-------------|------|
+| `:string` | string | the default if param type is missing, anything (single path segment) | `Params().Get` |
+| `:int` | int | -9223372036854775808 to 9223372036854775807 (x64) or -2147483648 to 2147483647 (x32), depends on the host arch | `Params().GetInt` |
+| `:int8` | int8 | -128 to 127 | `Params().GetInt8` |
+| `:int16` | int16 | -32768 to 32767 | `Params().GetInt16` |
+| `:int32` | int32 | -2147483648 to 2147483647 | `Params().GetInt32` |
+| `:int64` | int64 | -9223372036854775808 to 9223372036854775807 | `Params().GetInt64` |
+| `:uint` | uint | 0 to 18446744073709551615 (x64) or 0 to 4294967295 (x32), depends on the host arch | `Params().GetUint` |
+| `:uint8` | uint8 | 0 to 255 | `Params().GetUint8` |
+| `:uint16` | uint16 | 0 to 65535 | `Params().GetUint16` |
+| `:uint32` | uint32 | 0 to 4294967295 | `Params().GetUint32` |
+| `:uint64` | uint64 | 0 to 18446744073709551615 | `Params().GetUint64` |
+| `:bool` | bool | "1" or "t" or "T" or "TRUE" or "true" or "True" or "0" or "f" or "F" or "FALSE" or "false" or "False" | `Params().GetBool` |
+| `:alphabetical` | string | lowercase or uppercase letters | `Params().Get` |
+| `:file` | string | lowercase or uppercase letters, numbers, underscore (_), dash (-), point (.) and no spaces or other special characters that are not valid for filenames | `Params().Get` |
+| `:path` | string | anything, can be separated by slashes (path segments) but should be the last part of the route path | `Params().Get` | 
+
+**Usage**:
+
+```go
+app.Get("/users/{id:uint64}", func(ctx iris.Context){
+    id, _ := ctx.Params().GetUint64("id")
+    // [...]
+})
+```
+
+| Built'n Func | Param Types |
+| -----------|---------------|
+| `regexp`(expr string) | :string |
+| `prefix`(prefix string) | :string |
+| `suffix`(suffix string) | :string |
+| `contains`(s string) | :string |
+| `min`(minValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64  or float32 or float64) | :string(char length), :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64  |
+| `max`(maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64 or float32 or float64) | :string(char length), :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64 |
+| `range`(minValue, maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64 or float32 or float64) | :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64 |
+
+**Usage**:
+
+```go
+app.Get("/profile/{name:alphabetical max(255)}", func(ctx iris.Context){
+    name := ctx.Params().Get("name")
+    // len(name) <=255 otherwise this route will fire 404 Not Found
+    // and this handler will not be executed at all.
+})
+```
+
+## Vendoring
+
+- Rename the vendor `sessions/sessiondb/vendor/...bbolt` from `coreos/bbolt` to `etcd-io/bbolt` and update to v1.3.1, based on [that](https://github.com/etcd-io/bbolt/releases/tag/v1.3.1-etcd.7)
+- Update the vendor `sessions/sessiondb/vendor/...badger` to v1.5.3
+
+I believe it is soon to adapt the new [go modules](https://github.com/golang/go/wiki/Modules#table-of-contents) inside Iris, the new `go mod` command may change until go 1.12, it is still an experimental feature.
+The [vendor](https://github.com/kataras/iris/tree/master/vendor) folder will be kept until the majority of Go developers get acquainted with the new `go modules`.  The `go.mod` and `go.sum` files will come at `iris v12` (or `go 1.12`), we could do that on this version as well but I don't want to have half-things, versioning should be passed on import path as well and that is a large breaking change to go with it right now, so it will probably have a new path such as `github.com/kataras/iris/v12` based on a `git tag` like every Iris release (we are lucky here because we used semantic versioning from day zero). No folder re-structure inside the root git repository to split versions will ever happen, so backwards-compatibility for older go versions(before go 1.9.3) and iris versions will be not enabled by-default although it's easy for anyone to grab any version from older [releases](https://github.com/kataras/iris/releases) or branch and target that.
+
 # Sat, 11 August 2018 | v10.7.0
 
 I am overjoyed to announce stage 1 of the the Iris Web framework **10.7 stable release is now available**.
@@ -228,7 +396,7 @@ For example: at [_examples/mvc/basic/main.go line 100](_examples/mvc/basic/main.
 
 - fix `APIBuilder, Party#StaticWeb` and `APIBuilder, Party#StaticEmbedded` wrong strip prefix inside children parties
 - keep the `iris, core/router#StaticEmbeddedHandler` and remove the `core/router/APIBuilder#StaticEmbeddedHandler`,  (note the `Handler` suffix) it's global and has nothing to do with the `Party` or the `APIBuilder`
-- fix high path cleaning between `{}` (we already escape those contents at the [interpreter](core/router/macro/interpreter) level but some symbols are still removed by the higher-level api builder) , i.e `\\` from the string's macro function `regex` contents as reported at [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
+- fix high path cleaning between `{}` (we already escape those contents at the [interpreter](macro/interpreter) level but some symbols are still removed by the higher-level api builder) , i.e `\\` from the string's macro function `regex` contents as reported at [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
 - sync the `golang.org/x/sys/unix` vendor
 
 ## The most important

HISTORY_GR.md

@@ -17,9 +17,13 @@
 
 **Πώς να αναβαθμίσετε**: Ανοίξτε την γραμμή εντολών σας και εκτελέστε αυτήν την εντολή: `go get -u github.com/kataras/iris`  ή αφήστε το αυτόματο updater να το κάνει αυτό για σας.
 
+# Su, 21 October 2018 | v11.0.0
+
+Πατήστε [εδώ](https://github.com/kataras/iris/blob/master/HISTORY.md#su-21-october-2018--v11) για να διαβάσετε στα αγγλικά τις αλλαγές και τα νέα features που φέρνει νεότερη έκδοση του Iris, version 11.
+
 # Sat, 11 August 2018 | v10.7.0
 
-Είμαι στην πραγματικά ευχάριστη θέση να σας ανακοινώσω το πρώτο στάδιο της σταθερής κυκλοφορίας της έκδοσης **10.7** του Iris Web Framework.
+Είμαι στην, πραγματικά, ευχάριστη θέση να σας ανακοινώσω το πρώτο στάδιο της σταθερής κυκλοφορίας της έκδοσης **10.7** του Iris Web Framework.
 
 Η έκδοση 10.7.0 είναι μέρος των [επίσημων διανομών μας](https://github.com/kataras/iris/releases).
 

HISTORY_ID.md

@@ -17,6 +17,10 @@ Developers tidak diwajibkan untuk melakukan upgrade apabila mereka tidak membutu
 
 **Cara Upgrade**: Bukan command-line anda dan eksekuis perintah ini: `go get -u github.com/kataras/iris` atau biarkan updater otomatis melakukannya untuk anda.
 
+# Su, 21 October 2018 | v11.0.0
+
+This history entry is not translated yet to the Indonesian language yet, please refer to the english version of the [HISTORY entry](https://github.com/kataras/iris/blob/master/HISTORY.md#su-21-october-2018--v11) instead.
+
 # Sat, 11 August 2018 | v10.7.0
 
 This history entry is not translated yet to the Indonesian language yet, please refer to the english version of the [HISTORY entry](https://github.com/kataras/iris/blob/master/HISTORY.md#sat-11-august-2018--v1070) instead.
@@ -83,7 +87,7 @@ For example: at [_examples/mvc/basic/main.go line 100](_examples/mvc/basic/main.
 
 - fix `APIBuilder, Party#StaticWeb` and `APIBuilder, Party#StaticEmbedded` wrong strip prefix inside children parties
 - keep the `iris, core/router#StaticEmbeddedHandler` and remove the `core/router/APIBuilder#StaticEmbeddedHandler`,  (note the `Handler` suffix) it's global and has nothing to do with the `Party` or the `APIBuilder`
-- fix high path cleaning between `{}` (we already escape those contents at the [interpreter](core/router/macro/interpreter) level but some symbols are still removed by the higher-level api builder) , i.e `\\` from the string's macro function `regex` contents as reported at [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
+- fix high path cleaning between `{}` (we already escape those contents at the [interpreter](macro/interpreter) level but some symbols are still removed by the higher-level api builder) , i.e `\\` from the string's macro function `regex` contents as reported at [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
 - sync the `golang.org/x/sys/unix` vendor
 
 ## The most important

HISTORY_ZH.md

@@ -17,6 +17,10 @@
 
 **如何升级**: 打开命令行执行以下命令: `go get -u github.com/kataras/iris` 或者等待自动更新。
 
+# Su, 21 October 2018 | v11.0.0
+
+This history entry is not translated yet to the Chinese language yet, please refer to the english version of the [HISTORY entry](https://github.com/kataras/iris/blob/master/HISTORY.md#su-21-october-2018--v11) instead.
+
 # Sat, 11 August 2018 | v10.7.0
 
 This history entry is not translated yet to the Chinese language yet, please refer to the english version of the [HISTORY entry](https://github.com/kataras/iris/blob/master/HISTORY.md#sat-11-august-2018--v1070) instead.
@@ -79,7 +83,7 @@ This history entry is not translated yet to the Chinese language yet, please ref
 
 - 修正 `APIBuilder, Party#StaticWeb` 和 `APIBuilder, Party#StaticEmbedded` 子分组内的前缀错误
 - 保留 `iris, core/router#StaticEmbeddedHandler` 并移除 `core/router/APIBuilder#StaticEmbeddedHandler`,  (`Handler` 后缀) 这是全局性的，与 `Party` `APIBuilder` 无关。
-- 修正 路径 `{}` 中的路径清理 (我们已经在 [解释器](core/router/macro/interpreter) 级别转义了这些字符， 但是一些符号仍然被更高级别的API构建器删除) , 例如 `\\` 字符串的宏函数正则表达式内容 [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
+- 修正 路径 `{}` 中的路径清理 (我们已经在 [解释器](macro/interpreter) 级别转义了这些字符， 但是一些符号仍然被更高级别的API构建器删除) , 例如 `\\` 字符串的宏函数正则表达式内容 [927](https://github.com/kataras/iris/issues/927) by [commit e85b113476eeefffbc7823297cc63cd152ebddfd](https://github.com/kataras/iris/commit/e85b113476eeefffbc7823297cc63cd152ebddfd)
 - 同步 `golang.org/x/sys/unix`
 
 ## 重要变更

README.md

@@ -1,14 +1,8 @@
-# ⚡️ The upcoming release is in-progress
-
-Please stay tuned by following its changelog before its official release. Click [here](https://github.com/kataras/iris/blob/v11/HISTORY.md#whenever--v1100) to read more about the upcoming release, version 11.
-
-> And, for the craziest of us, click [here](https://github.com/kataras/iris/compare/v10.7.0...v11) 🔥 to find out the commits and the code changes since current v10 
-
 # Iris Web Framework <a href="README_ZH.md"> <img width="20px" src="https://iris-go.com/images/flag-china.svg?v=10" /></a> <a href="README_RU.md"><img width="20px" src="https://iris-go.com/images/flag-russia.svg?v=10" /></a> <a href="README_ID.md"> <img width="20px" src="https://iris-go.com/images/flag-indonesia.svg?v=10" /></a> <a href="README_GR.md"><img width="20px" src="https://iris-go.com/images/flag-greece.svg?v=10" /></a> <a href="README_PT_BR.md"><img width="20px" src="https://iris-go.com/images/flag-pt-br.svg?v=10" /></a> <a href="README_JPN.md"><img width="20px" src="https://iris-go.com/images/flag-japan.svg?v=10" /></a>
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/routing%20by-example-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Iris is a fast, simple yet fully featured and very efficient web framework for Go.
 
@@ -119,10 +113,18 @@ func main() {
 
 | Param Type | Go Type | Validation | Retrieve Helper |
 | -----------------|------|-------------|------|
-| `:string` | string | anything | `Params().Get` |
-| `:int` | uint, uint8, uint16, uint32, uint64, int, int8, int32, int64 | positive number, no digits limit | `Params().GetInt/Int64`...|
-| `:long` | int64 | -9223372036854775808 to 9223372036854775807 | `Params().GetInt64` |
-| `:boolean` | bool | "1" or "t" or "T" or "TRUE" or "true" or "True" or "0" or "f" or "F" or "FALSE" or "false" or "False" | `Params().GetBool` |
+| `:string` | string | anything (single path segment) | `Params().Get` |
+| `:int` | int | -9223372036854775808 to 9223372036854775807 (x64) or -2147483648 to 2147483647 (x32), depends on the host arch | `Params().GetInt` |
+| `:int8` | int8 | -128 to 127 | `Params().GetInt8` |
+| `:int16` | int16 | -32768 to 32767 | `Params().GetInt16` |
+| `:int32` | int32 | -2147483648 to 2147483647 | `Params().GetInt32` |
+| `:int64` | int64 | -9223372036854775808 to 9223372036854775807 | `Params().GetInt64` |
+| `:uint` | uint | 0 to 18446744073709551615 (x64) or 0 to 4294967295 (x32), depends on the host arch | `Params().GetUint` |
+| `:uint8` | uint8 | 0 to 255 | `Params().GetUint8` |
+| `:uint16` | uint16 | 0 to 65535 | `Params().GetUint16` |
+| `:uint32` | uint32 | 0 to 4294967295 | `Params().GetUint32` |
+| `:uint64` | uint64 | 0 to 18446744073709551615 | `Params().GetUint64` |
+| `:bool` | bool | "1" or "t" or "T" or "TRUE" or "true" or "True" or "0" or "f" or "F" or "FALSE" or "false" or "False" | `Params().GetBool` |
 | `:alphabetical` | string | lowercase or uppercase letters | `Params().Get` |
 | `:file` | string | lowercase or uppercase letters, numbers, underscore (_), dash (-), point (.) and no spaces or other special characters that are not valid for filenames | `Params().Get` |
 | `:path` | string | anything, can be separated by slashes (path segments) but should be the last part of the route path | `Params().Get` | 
@@ -130,8 +132,8 @@ func main() {
 **Usage**:
 
 ```go
-app.Get("/users/{id:int64}", func(ctx iris.Context){
-    id, _ := ctx.Params().GetInt64("id")
+app.Get("/users/{id:uint64}", func(ctx iris.Context){
+    id := ctx.Params().GetUint64Default("id", 0)
     // [...]
 })
 ```
@@ -142,9 +144,9 @@ app.Get("/users/{id:int64}", func(ctx iris.Context){
 | `prefix`(prefix string) | :string |
 | `suffix`(suffix string) | :string |
 | `contains`(s string) | :string |
-| `min`(minValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64  or float32 or float64) | :string(char length), :int, :int64 |
-| `max`(maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64  or float32 or float64) | :string(char length), :int, :int64 |
-| `range`(minValue, maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64 or float32 or float64) | :int, :int64 |
+| `min`(minValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64  or float32 or float64) | :string(char length), :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64  |
+| `max`(maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64 or float32 or float64) | :string(char length), :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64 |
+| `range`(minValue, maxValue int or int8 or int16 or int32 or int64 or uint8 or uint16 or uint32 or uint64 or float32 or float64) | :int, :int8, :int16, :int32, :int64, :uint, :uint8, :uint16, :uint32, :uint64 |
 
 **Usage**:
 
@@ -168,7 +170,7 @@ latLonRegex, _ := regexp.Compile(latLonExpr)
 
 // Register your custom argument-less macro function to the :string param type.
 // MatchString is a type of func(string) bool, so we use it as it is.
-app.Macros().String.RegisterFunc("coordinate", latLonRegex.MatchString)
+app.Macros().Get("string").RegisterFunc("coordinate", latLonRegex.MatchString)
 
 app.Get("/coordinates/{lat:string coordinate()}/{lon:string coordinate()}", func(ctx iris.Context) {
     ctx.Writef("Lat: %s | Lon: %s", ctx.Params().Get("lat"), ctx.Params().Get("lon"))
@@ -179,7 +181,7 @@ Register your custom macro function which accepts two int arguments.
 
 ```go
 
-app.Macros().String.RegisterFunc("range", func(minLength, maxLength int) func(string) bool {
+app.Macros().Get("string").RegisterFunc("range", func(minLength, maxLength int) func(string) bool {
     return func(paramValue string) bool {
         return len(paramValue) >= minLength && len(paramValue) <= maxLength
     }
@@ -195,7 +197,7 @@ app.Get("/limitchar/{name:string range(1,200) else 400}", func(ctx iris.Context)
 Register your custom macro function which accepts a slice of strings `[...,...]`.
 
 ```go
-app.Macros().String.RegisterFunc("has", func(validNames []string) func(string) bool {
+app.Macros().Get("string").RegisterFunc("has", func(validNames []string) func(string) bool {
     return func(paramValue string) bool {
         for _, validName := range validNames {
             if validName == paramValue {
@@ -218,32 +220,32 @@ app.Get("/static_validation/{name:string has([kataras,gerasimos,maropoulos]}", f
 
 ```go
 func main() {
-	app := iris.Default()
+    app := iris.Default()
 
-	// This handler will match /user/john but will not match neither /user/ or /user.
-	app.Get("/user/{name}", func(ctx iris.Context) {
-		name := ctx.Params().Get("name")
-		ctx.Writef("Hello %s", name)
-	})
+    // This handler will match /user/john but will not match neither /user/ or /user.
+    app.Get("/user/{name}", func(ctx iris.Context) {
+        name := ctx.Params().Get("name")
+        ctx.Writef("Hello %s", name)
+    })
 
-	// This handler will match /users/42
-	// but will not match
-	// neither /users or /users/.
-	app.Get("/users/{id:long}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt64("id")
-		ctx.Writef("User with ID: %d", id)
-	})
+    // This handler will match /users/42
+    // but will not match /users/-1 because uint should be bigger than zero
+    // neither /users or /users/.
+    app.Get("/users/{id:uint64}", func(ctx iris.Context) {
+        id := ctx.Params().GetUint64Default("id", 0)
+        ctx.Writef("User with ID: %d", id)
+    })
 
-	// This handler will match /user/john/send
-	// but will not match /user/john/
-	app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
-		name := ctx.Params().Get("name")
-		action := ctx.Params().Get("action")
-		message := name + " is " + action
-		ctx.WriteString(message)
-	})
+    // However, this one will match /user/john/send and also /user/john/everything/else/here
+    // but will not match /user/john neither /user/john/.
+    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
+        name := ctx.Params().Get("name")
+        action := ctx.Params().Get("action")
+        message := name + " is " + action
+        ctx.WriteString(message)
+    })
 
-	app.Run(iris.Addr(":8080"))
+    app.Run(iris.Addr(":8080"))
 }
 ```
 
@@ -251,6 +253,7 @@ func main() {
 
 > Learn more about path parameter's types by navigating [here](_examples/routing/dynamic-path/main.go#L31).
 
+
 ### Dependency Injection
 
 The package [hero](hero) contains features for binding any object or functions that `handlers` can use, these are called dependencies.
@@ -592,7 +595,6 @@ func main() {
     app.Run(
         iris.Addr(":8080"),
         iris.WithoutBanner,
-        iris.WithoutVersionChecker,
         iris.WithoutServerError(iris.ErrServerClosed),
     )
 }
@@ -897,7 +899,7 @@ func main() {
 
 ### Testing
 
-Iris offers an incredible support for the [httpexpect](https://github.com/iris-contrib/httpexpect), a Testing Framework for web applications. However, you are able to use the standard Go's `net/http/httptest` package as well but in this example we will use the `kataras/iris/httptest`.
+Iris offers an incredible support for the [httpexpect](github.com/iris-contrib/httpexpect), a Testing Framework for web applications. However, you are able to use the standard Go's `net/http/httptest` package as well but in this example we will use the `kataras/iris/httptest`.
 
 ```go
 package main
@@ -1004,7 +1006,7 @@ Iris, unlike others, is 100% compatible with the standards and that's why the ma
 
 ## Support
 
-- [HISTORY](HISTORY.md#sat-11-august-2018--v1070) file is your best friend, it contains information about the latest features and changes
+- [HISTORY](HISTORY.md#su-21-october-2018--v1100) file is your best friend, it contains information about the latest features and changes
 - Did you happen to find a bug? Post it at [github issues](https://github.com/kataras/iris/issues)
 - Do you have any questions or need to speak with someone experienced to solve a problem at real-time? Join us to the [community chat](https://chat.iris-go.com)
 - Complete our form-based user experience report by clicking [here](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)

README_GR.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Το Iris είναι ένα γρήγορο, απλό αλλά και πλήρως λειτουργικό και πολύ αποδοτικό web framework για τη Go.
 
@@ -108,7 +108,7 @@ _Η τελευταία ενημέρωση έγινε την [Τρίτη, 21 Νο
 
 ## Υποστήριξη
 
-- To [HISTORY](HISTORY_GR.md#sat-11-august-2018--v1070) αρχείο είναι ο καλύτερος σας φίλος, περιέχει πληροφορίες σχετικά με τις τελευταίες λειτουργίες(features) και αλλαγές
+- To [HISTORY](HISTORY_GR.md#su-21-october-2018--v1100) αρχείο είναι ο καλύτερος σας φίλος, περιέχει πληροφορίες σχετικά με τις τελευταίες λειτουργίες(features) και αλλαγές
 - Μήπως τυχαίνει να βρήκατε κάποιο bug; Δημοσιεύστε το στα [github issues](https://github.com/kataras/iris/issues)
 - Έχετε οποιεσδήποτε ερωτήσεις ή πρέπει να μιλήσετε με κάποιον έμπειρο για την επίλυση ενός προβλήματος σε πραγματικό χρόνο; Ελάτε μαζί μας στην [συνομιλία κοινότητας](https://chat.iris-go.com)
 - Συμπληρώστε την αναφορά εμπειρίας χρήστη κάνοντας κλικ [εδώ](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)

README_ID.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Iris adalah web framework yang cepat, sederhana namun berfitur lengkap dan sangat efisien untuk Go.
 
@@ -106,7 +106,7 @@ _Diperbarui pada: [Tuesday, 21 November 2017](_benchmarks/README_UNIX.md)_
 
 ## Dukungan
 
-- File [HISTORY](HISTORY_ID.md#sat-11-august-2018--v1070) adalah sahabat anda, file tersebut memiliki informasi terkait fitur dan perubahan terbaru
+- File [HISTORY](HISTORY_ID.md#su-21-october-2018--v1100) adalah sahabat anda, file tersebut memiliki informasi terkait fitur dan perubahan terbaru
 - Apakah anda menemukan bug? Laporkan itu melalui [github issues](https://github.com/kataras/iris/issues)
 - Apakah anda memiliki pertanyaan atau butuh untuk bicara kepada seseorang yang sudah berpengalaman untuk menyelesaikan masalah secara langsung? Gabung bersama kami di [community chat](https://chat.iris-go.com)
 - Lengkapi laporan user-experience berbasis formulir kami dengan tekan [disini](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)

README_JPN.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Irisはシンプルで高速、それにも関わらず充実した機能を有する効率的なGo言語のウェブフレームワークです。
 
@@ -106,7 +106,7 @@ _Updated at: [Tuesday, 21 November 2017](_benchmarks/README_UNIX.md)_
 
 ## 支援
 
-- [HISTORY](HISTORY.md#sat-11-august-2018--v1070)ファイルはあなたの友人です。このファイルには、機能に関する最新の情報や変更点が記載されています。
+- [HISTORY](HISTORY.md#su-21-october-2018--v1100)ファイルはあなたの友人です。このファイルには、機能に関する最新の情報や変更点が記載されています。
 - バグを発見しましたか？[github issues](https://github.com/kataras/iris/issues)に投稿をお願い致します。
 - 質問がありますか？または問題を即時に解決するため、熟練者に相談する必要がありますか？[community chat](https://chat.iris-go.com)に参加しましょう。
 - [here](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)をクリックしてユーザーとしての体験を報告しましょう。

README_PT_BR.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Iris é um framework rápido, simples porém completo e muito eficiente para a linguagem Go.
 
@@ -106,7 +106,7 @@ _Atualizado em : [Terça, 21 de Novembro de 2017](_benchmarks/README_UNIX.md)_
 
 ## Apoie
 
-- [HISTORY](HISTORY.md#sat-11-august-2018--v1070) o arquivo HISTORY é o seu melhor amigo, ele contém informações sobre as últimas features e mudanças.
+- [HISTORY](HISTORY.md#su-21-october-2018--v1100) o arquivo HISTORY é o seu melhor amigo, ele contém informações sobre as últimas features e mudanças.
 - Econtrou algum bug ? Poste-o nas [issues](https://github.com/kataras/iris/issues)
 - Possui alguma dúvida ou gostaria de falar com alguém experiente para resolver seu problema em tempo real ? Junte-se ao [chat da nossa comunidade](https://chat.iris-go.com).
 - Complete nosso formulário de experiência do usuário clicando [aqui](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)

README_RU.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Iris - это быстрая, простая, но полнофункциональная и очень эффективная веб-платформа для Go.
 
@@ -106,7 +106,7 @@ _Обновлено: [Вторник, 21 ноября 2017 г.](_benchmarks/READ
 
 ## Поддержка
 
-- Файл [HISTORY](HISTORY.md#sat-11-august-2018--v1070) - ваш лучший друг, он содержит информацию о последних особенностях и всех изменениях
+- Файл [HISTORY](HISTORY.md#su-21-october-2018--v1100) - ваш лучший друг, он содержит информацию о последних особенностях и всех изменениях
 - Вы случайно обнаружили ошибку? Опубликуйте ее на [Github вопросы](https://github.com/kataras/iris/issues)
 - У Вас есть какие-либо вопросы или Вам нужно поговорить с кем-то, кто бы смог решить Вашу проблему в режиме реального времени? Присоединяйтесь к нам в [чате сообщества](https://chat.iris-go.com)
 - Заполните наш отчет о пользовательском опыте на основе формы, нажав [здесь](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link) 

README_ZH.md

@@ -2,7 +2,7 @@
 
 <a href="https://iris-go.com"> <img align="right" width="169px" src="https://iris-go.com/images/icon.svg?v=a" title="logo created by @merry.dii" /> </a>
 
-[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://iris-go.com/v10/recipe) [![release](https://img.shields.io/badge/release%20-v10.7-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
+[![build status](https://img.shields.io/travis/kataras/iris/master.svg?style=flat-square)](https://travis-ci.org/kataras/iris)<!-- [![release](https://img.shields.io/github/release/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/releases)--> [![report card](https://img.shields.io/badge/report%20card-a%2B-ff3333.svg?style=flat-square)](http://goreportcard.com/report/kataras/iris) [![vscode-iris](https://img.shields.io/badge/ext%20-vscode-0c77e3.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=kataras2006.iris)<!--[![github closed issues](https://img.shields.io/github/issues-closed-raw/kataras/iris.svg?style=flat-square)](https://github.com/kataras/iris/issues?q=is%3Aissue+is%3Aclosed)--> [![chat](https://img.shields.io/badge/community-%20chat-00BCD4.svg?style=flat-square)](https://kataras.rocket.chat/channel/iris) [![view examples](https://img.shields.io/badge/learn%20by-examples-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/tree/master/_examples/routing) [![release](https://img.shields.io/badge/release%20-v11.0-0077b3.svg?style=flat-square)](https://github.com/kataras/iris/releases)
 
 Iris 是一款超快、简洁高效的 Go 语言 Web开发框架。
 

VERSION

@@ -1 +1 @@
-10.7.0:https://github.com/kataras/iris/blob/master/HISTORY.md#sat-11-august-2018--v1070
+11.0.0:https://github.com/kataras/iris/blob/master/HISTORY.md#su-21-october-2018--v1100

_benchmarks/iris-mvc-templates/main.go

@@ -24,7 +24,7 @@ func main() {
 
 	mvc.New(app).Handle(new(controllers.HomeController))
 
-	app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":5000"))
 }
 
 type err struct {

_benchmarks/iris-mvc/main.go

@@ -16,7 +16,7 @@ func main() {
 	mvc.New(app.Party("/api/values/{id}")).
 		Handle(new(controllers.ValuesController))
 
-	app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":5000"))
 }
 
 // +2MB/s faster than the previous implementation, 0.4MB/s difference from the raw handlers.

_benchmarks/iris-sessions/main.go

@@ -24,9 +24,7 @@ func main() {
 	 app.Delete("/del", delHandler)
 	*/
 
-	// 24 August 2017: Iris has a built'n version updater but we don't need it
-	// when benchmarking...
-	app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":5000"))
 }
 
 // Set and Get

_benchmarks/iris/main.go

@@ -8,5 +8,5 @@ func main() {
 		ctx.WriteString("value")
 	})
 
-	app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":5000"))
 }

_examples/README.md

@@ -146,8 +146,10 @@ Navigate through examples for a better understanding.
 - [Custom HTTP Errors](routing/http-errors/main.go)
 - [Dynamic Path](routing/dynamic-path/main.go)
     * [root level wildcard path](routing/dynamic-path/root-wildcard/main.go)
+- [Write your own custom parameter types](routing/macros/main.go) **NEW**
 - [Reverse routing](routing/reverse/main.go)
-- [Custom wrapper](routing/custom-wrapper/main.go)
+- [Custom Router (high-level)](routing/custom-high-level-router/main.go) **NEW**
+- [Custom Wrapper](routing/custom-wrapper/main.go)
 - Custom Context
     * [method overriding](routing/custom-context/method-overriding/main.go)
     * [new implementation](routing/custom-context/new-implementation/main.go)

_examples/README_ZH.md

@@ -105,7 +105,9 @@ app.Get("{root:path}", rootWildcardHandler)
 - [自定义 HTTP 错误](routing/http-errors/main.go)
 - [动态路径](routing/dynamic-path/main.go)
     * [根级通配符路径](routing/dynamic-path/root-wildcard/main.go)
+- [Write your own custom parameter types](routing/macros/main.go) **NEW**
 - [反向路由](routing/reverse/main.go)
+- [Custom Router (high-level)](routing/custom-high-level-router/main.go) **NEW**
 - [自定义包装](routing/custom-wrapper/main.go)
 - 自定义上下文
     * [方法重写](routing/custom-context/method-overriding/main.go)

_examples/hero/overview/main.go

@@ -50,8 +50,6 @@ func main() {
 	app.Run(
 		// Start the web server at localhost:8080
 		iris.Addr("localhost:8080"),
-		// disables updates:
-		iris.WithoutVersionChecker,
 		// skip err server closed when CTRL/CMD+C pressed:
 		iris.WithoutServerError(iris.ErrServerClosed),
 		// enables faster json serialization and more:

_examples/hero/sessions/main.go

@@ -34,7 +34,6 @@ func main() {
 
 	app.Run(
 		iris.Addr(":8080"),
-		iris.WithoutVersionChecker,
 		iris.WithoutServerError(iris.ErrServerClosed),
 	)
 }

_examples/http-listening/iris-configurator-and-host-configurator/README.md

@@ -1,2 +0,0 @@
-A silly example for this issue: https://github.com/kataras/iris/issues/688#issuecomment-318828259.
-However it seems useful and therefore is being included in the examples for everyone else.

_examples/http-listening/iris-configurator-and-host-configurator/counter/configurator.go

@@ -1,30 +0,0 @@
-package counter
-
-import (
-	"time"
-
-	"github.com/kataras/iris"
-	"github.com/kataras/iris/core/host"
-)
-
-func Configurator(app *iris.Application) {
-	counterValue := 0
-
-	go func() {
-		ticker := time.NewTicker(time.Second)
-
-		for range ticker.C {
-			counterValue++
-		}
-
-		app.ConfigureHost(func(h *host.Supervisor) { // <- HERE: IMPORTANT
-			h.RegisterOnShutdown(func() {
-				ticker.Stop()
-			})
-		}) // or put the ticker outside of the gofunc and put the configurator before or after the app.Get, outside of this gofunc
-	}()
-
-	app.Get("/counter", func(ctx iris.Context) {
-		ctx.Writef("Counter value = %d", counterValue)
-	})
-}

_examples/http-listening/iris-configurator-and-host-configurator/main.go

@@ -1,14 +1,28 @@
 package main
 
 import (
-	"github.com/kataras/iris/_examples/http-listening/iris-configurator-and-host-configurator/counter"
-
 	"github.com/kataras/iris"
 )
 
 func main() {
 	app := iris.New()
-	app.Configure(counter.Configurator)
 
-	app.Run(iris.Addr(":8080"))
+	app.ConfigureHost(func(host *iris.Supervisor) { // <- HERE: IMPORTANT
+		// You can control the flow or defer something using some of the host's methods:
+		// host.RegisterOnError
+		// host.RegisterOnServe
+		host.RegisterOnShutdown(func() {
+			app.Logger().Infof("Application shutdown on signal")
+		})
+	})
+
+	app.Get("/", func(ctx iris.Context) {
+		ctx.HTML("<h1>Hello</h1>\n")
+	})
+
+	app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
+
+	/* There are more easy ways to notify for global shutdown using the `iris.RegisterOnInterrupt` for default signal interrupt events.
+	You can even go it even further by looking at the: "graceful-shutdown" example.
+	*/
 }

_examples/http-listening/notify-on-shutdown/main.go

@@ -1,11 +1,10 @@
 package main
 
 import (
-	stdContext "context"
+	"context"
 	"time"
 
 	"github.com/kataras/iris"
-	"github.com/kataras/iris/core/host"
 )
 
 func main() {
@@ -15,20 +14,20 @@ func main() {
 		ctx.HTML("<h1>Hello, try to refresh the page after ~10 secs</h1>")
 	})
 
-	// app.ConfigureHost(configureHost) -> or pass "configureHost" as `app.Addr` argument, same result.
-
 	app.Logger().Info("Wait 10 seconds and check your terminal again")
 	// simulate a shutdown action here...
 	go func() {
 		<-time.After(10 * time.Second)
 		timeout := 5 * time.Second
-		ctx, cancel := stdContext.WithTimeout(stdContext.Background(), timeout)
+		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 		defer cancel()
 		// close all hosts, this will notify the callback we had register
 		// inside the `configureHost` func.
 		app.Shutdown(ctx)
 	}()
 
+	// app.ConfigureHost(configureHost) -> or pass "configureHost" as `app.Addr` argument, same result.
+
 	// start the server as usual, the only difference is that
 	// we're adding a second (optional) function
 	// to configure the just-created host supervisor.
@@ -37,9 +36,14 @@ func main() {
 	// wait 10 seconds and check your terminal.
 	app.Run(iris.Addr(":8080", configureHost), iris.WithoutServerError(iris.ErrServerClosed))
 
+	/*
+		Or for simple cases you can just use the:
+		iris.RegisterOnInterrupt for global catch of the CTRL/CMD+C and OS events.
+		Look at the "graceful-shutdown" example for more.
+	*/
 }
 
-func configureHost(su *host.Supervisor) {
+func configureHost(su *iris.Supervisor) {
 	// here we have full access to the host that will be created
 	// inside the `app.Run` function or `NewHost`.
 	//

_examples/http_request/extract-referer/main.go

@@ -25,5 +25,5 @@ func main() {
 
 	// http://localhost:8080?referer=https://twitter.com/Xinterio/status/1023566830974251008
 	// http://localhost:8080?referer=https://www.google.com/search?q=Top+6+golang+web+frameworks&oq=Top+6+golang+web+frameworks
-	app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
 }

_examples/mvc/login/main.go

@@ -79,8 +79,6 @@ func main() {
 	app.Run(
 		// Starts the web server at localhost:8080
 		iris.Addr("localhost:8080"),
-		// Disables the updater.
-		iris.WithoutVersionChecker,
 		// Ignores err server closed log when CTRL/CMD+C pressed.
 		iris.WithoutServerError(iris.ErrServerClosed),
 		// Enables faster json serialization and more.

_examples/mvc/overview/main.go

@@ -33,8 +33,6 @@ func main() {
 	app.Run(
 		// Start the web server at localhost:8080
 		iris.Addr("localhost:8080"),
-		// disables updates:
-		iris.WithoutVersionChecker,
 		// skip err server closed when CTRL/CMD+C pressed:
 		iris.WithoutServerError(iris.ErrServerClosed),
 		// enables faster json serialization and more:

_examples/mvc/session-controller/main.go

@@ -68,5 +68,5 @@ func main() {
 	// 3. refresh the page some times
 	// 4. close the browser
 	// 5. re-open the browser and re-play 2.
-	app.Run(iris.Addr(":8080"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":8080"))
 }

_examples/overview/main.go

@@ -74,7 +74,7 @@ func main() {
 	}
 
 	// Listen for incoming HTTP/1.x & HTTP/2 clients on localhost port 8080.
-	app.Run(iris.Addr(":8080"), iris.WithCharset("UTF-8"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":8080"), iris.WithCharset("UTF-8"))
 }
 
 func logThisMiddleware(ctx iris.Context) {

_examples/routing/README.md

@@ -110,9 +110,9 @@ app := iris.New()
 users := app.Party("/users", myAuthMiddlewareHandler)
 
 // http://localhost:8080/users/42/profile
-users.Get("/{id:int}/profile", userProfileHandler)
+users.Get("/{id:uint64}/profile", userProfileHandler)
 // http://localhost:8080/users/messages/1
-users.Get("/inbox/{id:int}", userMessageHandler)
+users.Get("/inbox/{id:uint64}", userMessageHandler)
 ```
 
 The same could be also written using a function which accepts the child router(the Party).
@@ -124,13 +124,13 @@ app.PartyFunc("/users", func(users iris.Party) {
     users.Use(myAuthMiddlewareHandler)
 
     // http://localhost:8080/users/42/profile
-    users.Get("/{id:int}/profile", userProfileHandler)
+    users.Get("/{id:uint64}/profile", userProfileHandler)
     // http://localhost:8080/users/messages/1
-    users.Get("/inbox/{id:int}", userMessageHandler)
+    users.Get("/inbox/{id:uint64}", userMessageHandler)
 })
 ```
 
-> `id:int` is a (typed) dynamic path parameter, learn more by scrolling down.
+> `id:uint` is a (typed) dynamic path parameter, learn more by scrolling down.
 
 # Dynamic Path Parameters
 
@@ -152,23 +152,71 @@ Standard macro types for route path parameters
 | {param:string}         |
 +------------------------+
 string type
-anything
+anything (single path segmnent)
 
-+------------------------+
-| {param:int}            |
-+------------------------+
++-------------------------------+
+| {param:int}                   |
++-------------------------------+
 int type
-only numbers (0-9)
+-9223372036854775808 to 9223372036854775807 (x64) or -2147483648 to 2147483647 (x32), depends on the host arch
 
 +------------------------+
-| {param:long}           |
+| {param:int8}           |
++------------------------+
+int8 type
+-128 to 127
+
++------------------------+
+| {param:int16}          |
++------------------------+
+int16 type
+-32768 to 32767
+
++------------------------+
+| {param:int32}          |
++------------------------+
+int32 type
+-2147483648 to 2147483647
+
++------------------------+
+| {param:int64}          |
 +------------------------+
 int64 type
-only numbers (0-9)
+-9223372036854775808 to 9223372036854775807
 
 +------------------------+
-| {param:boolean}        |
+| {param:uint}           |
 +------------------------+
+uint type
+0 to 18446744073709551615 (x64) or 0 to 4294967295 (x32)
+
++------------------------+
+| {param:uint8}          |
++------------------------+
+uint8 type
+0 to 255
+
++------------------------+
+| {param:uint16}         |
++------------------------+
+uint16 type
+0 to 65535
+
++------------------------+
+| {param:uint32}          |
++------------------------+
+uint32 type
+0 to 4294967295
+
++------------------------+
+| {param:uint64}         |
++------------------------+
+uint64 type
+0 to 18446744073709551615
+
++---------------------------------+
+| {param:bool} or {param:boolean} |
++---------------------------------+
 bool type
 only "1" or "t" or "T" or "TRUE" or "true" or "True"
 or "0" or "f" or "F" or "FALSE" or "false" or "False"
@@ -194,8 +242,8 @@ no spaces ! or other character
 | {param:path}           |
 +------------------------+
 path type
-anything, should be the last part, more than one path segment,
-i.e: /path1/path2/path3 , ctx.Params().Get("param") == "/path1/path2/path3"
+anything, should be the last part, can be more than one path segment,
+i.e: "/test/*param" and request: "/test/path1/path2/path3" , ctx.Params().Get("param") == "path1/path2/path3"
 ```
 
 If type is missing then parameter's type is defaulted to string, so
@@ -209,18 +257,24 @@ you are able to register your own too!.
 Register a named path parameter function
 
 ```go
-app.Macros().Int.RegisterFunc("min", func(argument int) func(paramValue string) bool {
+app.Macros().Get("int").RegisterFunc("min", func(argument int) func(paramValue int) bool {
     // [...]
-    return true 
-    // -> true means valid, false means invalid fire 404 or if "else 500" is appended to the macro syntax then internal server error.
+    return func(paramValue int) bool {
+         // -> true means valid, false means invalid fire 404
+         // or if "else 500" is appended to the macro syntax then internal server error.
+        return true 
+    }
 })
 ```
 
-At the `func(argument ...)` you can have any standard type, it will be validated before the server starts so don't care about any performance cost there, the only thing it runs at serve time is the returning `func(paramValue string) bool`.
+At the `func(argument ...)` you can have any standard type, it will be validated before the server starts so don't care about any performance cost there, the only thing it runs at serve time is the returning `func(paramValue <T>) bool`.
 
 ```go
-{param:string equal(iris)} , "iris" will be the argument here:
-app.Macros().String.RegisterFunc("equal", func(argument string) func(paramValue string) bool {
+{param:string equal(iris)}
+```
+The "iris" will be the argument here:
+```go
+app.Macros().Get("string").RegisterFunc("equal", func(argument string) func(paramValue string) bool {
     return func(paramValue string){ return argument == paramValue }
 })
 ```
@@ -237,38 +291,34 @@ app.Get("/username/{name}", func(ctx iris.Context) {
 // Let's register our first macro attached to int macro type.
 // "min" = the function
 // "minValue" = the argument of the function
-// func(string) bool = the macro's path parameter evaluator, this executes in serve time when
+// func(<T>) bool = the macro's path parameter evaluator, this executes in serve time when
 // a user requests a path which contains the :int macro type with the min(...) macro parameter function.
-app.Macros().Int.RegisterFunc("min", func(minValue int) func(string) bool {
+app.Macros().Get("int").RegisterFunc("min", func(minValue int) func(int) bool {
     // do anything before serve here [...]
     // at this case we don't need to do anything
-    return func(paramValue string) bool {
-        n, err := strconv.Atoi(paramValue)
-        if err != nil {
-            return false
-        }
-        return n >= minValue
+    return func(paramValue int) bool {
+        return paramValue >= minValue
     }
 })
 
 // http://localhost:8080/profile/id>=1
 // this will throw 404 even if it's found as route on : /profile/0, /profile/blabla, /profile/-1
 // macro parameter functions are optional of course.
-app.Get("/profile/{id:int min(1)}", func(ctx iris.Context) {
+app.Get("/profile/{id:uint64 min(1)}", func(ctx iris.Context) {
     // second parameter is the error but it will always nil because we use macros,
     // the validaton already happened.
-    id, _ := ctx.Params().GetInt("id")
+    id, _ := ctx.Params().GetUint64("id")
     ctx.Writef("Hello id: %d", id)
 })
 
 // to change the error code per route's macro evaluator:
-app.Get("/profile/{id:int min(1)}/friends/{friendid:int min(1) else 504}", func(ctx iris.Context) {
-    id, _ := ctx.Params().GetInt("id")
-    friendid, _ := ctx.Params().GetInt("friendid")
+app.Get("/profile/{id:uint64 min(1)}/friends/{friendid:uint64 min(1) else 504}", func(ctx iris.Context) {
+    id, _ := ctx.Params().GetUint64("id")
+    friendid, _ := ctx.Params().GetUint64("friendid")
     ctx.Writef("Hello id: %d looking for friend id: ", id, friendid)
 }) // this will throw e 504 error code instead of 404 if all route's macros not passed.
 
-// http://localhost:8080/game/a-zA-Z/level/0-9
+// http://localhost:8080/game/a-zA-Z/level/42
 // remember, alphabetical is lowercase or uppercase letters only.
 app.Get("/game/{name:alphabetical}/level/{level:int}", func(ctx iris.Context) {
     ctx.Writef("name: %s | level: %s", ctx.Params().Get("name"), ctx.Params().Get("level"))
@@ -297,12 +347,10 @@ app.Run(iris.Addr(":8080"))
 }
 ```
 
-A **path parameter name should contain only alphabetical letters. Symbols like  '_' and numbers are NOT allowed**.
-
+A path parameter name should contain only alphabetical letters or digits. Symbols like  '_' are NOT allowed.
 Last, do not confuse `ctx.Params()` with `ctx.Values()`.
-Path parameter's values goes to `ctx.Params()` and context's local storage
-that can be used to communicate between handlers and middleware(s) goes to
-`ctx.Values()`.
+Path parameter's values can be retrieved from `ctx.Params()`,
+context's local storage that can be used to communicate between handlers and middleware(s) can be stored to `ctx.Values()`.
 
 # Routing and reverse lookups
 
@@ -776,6 +824,32 @@ type Context interface {
     // IsStopped checks and returns true if the current position of the Context is 255,
     // means that the StopExecution() was called.
     IsStopped() bool
+    // OnConnectionClose registers the "cb" function which will fire (on its own goroutine, no need to be registered goroutine by the end-dev)
+    // when the underlying connection has gone away.
+    //
+    // This mechanism can be used to cancel long operations on the server
+    // if the client has disconnected before the response is ready.
+    //
+    // It depends on the `http#CloseNotify`.
+    // CloseNotify may wait to notify until Request.Body has been
+    // fully read.
+    //
+    // After the main Handler has returned, there is no guarantee
+    // that the channel receives a value.
+    //
+    // Finally, it reports whether the protocol supports pipelines (HTTP/1.1 with pipelines disabled is not supported).
+    // The "cb" will not fire for sure if the output value is false.
+    //
+    // Note that you can register only one callback for the entire request handler chain/per route.
+    //
+    // Look the `ResponseWriter#CloseNotifier` for more.
+    OnConnectionClose(fnGoroutine func()) bool
+    // OnClose registers the callback function "cb" to the underline connection closing event using the `Context#OnConnectionClose`
+    // and also in the end of the request handler using the `ResponseWriter#SetBeforeFlush`.
+    // Note that you can register only one callback for the entire request handler chain/per route.
+    //
+    // Look the `Context#OnConnectionClose` and `ResponseWriter#SetBeforeFlush` for more.
+    OnClose(cb func())
 
     //  +------------------------------------------------------------+
     //  | Current "user/request" storage                             |
@@ -855,8 +929,12 @@ type Context interface {
     //
     // Keep note that this checks the "User-Agent" request header.
     IsMobile() bool
+    // GetReferrer extracts and returns the information from the "Referer" header as specified
+    // in https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
+    // or by the URL query parameter "referer".
+    GetReferrer() Referrer
     //  +------------------------------------------------------------+
-    //  | Response Headers helpers                                   |
+    //  | Headers helpers                                            |
     //  +------------------------------------------------------------+
 
     // Header adds a header to the response writer.
@@ -867,16 +945,18 @@ type Context interface {
     // GetContentType returns the response writer's header value of "Content-Type"
     // which may, setted before with the 'ContentType'.
     GetContentType() string
+    // GetContentType returns the request's header value of "Content-Type".
+    GetContentTypeRequested() string
 
     // GetContentLength returns the request's header value of "Content-Length".
     // Returns 0 if header was unable to be found or its value was not a valid number.
     GetContentLength() int64
 
     // StatusCode sets the status code header to the response.
-    // Look .GetStatusCode too.
+    // Look .`GetStatusCode` too.
     StatusCode(statusCode int)
     // GetStatusCode returns the current status code of the response.
-    // Look StatusCode too.
+    // Look `StatusCode` too.
     GetStatusCode() int
 
     // Redirect sends a redirect response to the client
@@ -911,6 +991,9 @@ type Context interface {
     // URLParamIntDefault returns the url query parameter as int value from a request,
     // if not found or parse failed then "def" is returned.
     URLParamIntDefault(name string, def int) int
+    // URLParamInt32Default returns the url query parameter as int32 value from a request,
+    // if not found or parse failed then "def" is returned.
+    URLParamInt32Default(name string, def int32) int32
     // URLParamInt64 returns the url query parameter as int64 value from a request,
     // returns -1 and an error if parse failed.
     URLParamInt64(name string) (int64, error)
@@ -1058,6 +1141,10 @@ type Context interface {
     // Examples of usage: context.ReadJSON, context.ReadXML.
     //
     // Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-custom-via-unmarshaler/main.go
+    //
+    // UnmarshalBody does not check about gzipped data.
+    // Do not rely on compressed data incoming to your server. The main reason is: https://en.wikipedia.org/wiki/Zip_bomb
+    // However you are still free to read the `ctx.Request().Body io.Reader` manually.
     UnmarshalBody(outPtr interface{}, unmarshaler Unmarshaler) error
     // ReadJSON reads JSON from request's body and binds it to a pointer of a value of any json-valid type.
     //
@@ -1068,7 +1155,8 @@ type Context interface {
     // Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-xml/main.go
     ReadXML(xmlObjectPtr interface{}) error
     // ReadForm binds the formObject  with the form data
-    // it supports any kind of struct.
+    // it supports any kind of type, including custom structs.
+    // It will return nothing if request data are empty.
     //
     // Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-form/main.go
     ReadForm(formObjectPtr interface{}) error

_examples/routing/basic/main.go

@@ -29,12 +29,12 @@ func main() {
 	app.Get("/donate", donateHandler, donateFinishHandler)
 
 	// Pssst, don't forget dynamic-path example for more "magic"!
-	app.Get("/api/users/{userid:int min(1)}", func(ctx iris.Context) {
-		userID, err := ctx.Params().GetInt("userid")
+	app.Get("/api/users/{userid:uint64 min(1)}", func(ctx iris.Context) {
+		userID, err := ctx.Params().GetUint64("userid")
 
 		if err != nil {
 			ctx.Writef("error while trying to parse userid parameter," +
-				"this will never happen if :int is being used because if it's not integer it will fire Not Found automatically.")
+				"this will never happen if :uint64 is being used because if it's not a valid uint64 it will fire Not Found automatically.")
 			ctx.StatusCode(iris.StatusBadRequest)
 			return
 		}

_examples/routing/custom-high-level-router/main.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"strings"
+
+	"github.com/kataras/iris"
+	"github.com/kataras/iris/context"
+	"github.com/kataras/iris/core/router"
+)
+
+/* A Router should contain all three of the following methods:
+   - HandleRequest should handle the request based on the Context.
+	  HandleRequest(ctx context.Context)
+   - Build should builds the handler, it's being called on router's BuildRouter.
+	  Build(provider router.RoutesProvider) error
+   - RouteExists reports whether a particular route exists.
+      RouteExists(ctx context.Context, method, path string) bool
+
+For a more detailed, complete and useful example
+you can take a look at the iris' router itself which is located at:
+https://github.com/kataras/iris/tree/master/core/router/handler.go
+which completes this exact interface, the `router#RequestHandler`.
+*/
+type customRouter struct {
+	// a copy of routes (safer because you will not be able to alter a route on serve-time without a `app.RefreshRouter` call):
+	// []router.Route
+	// or just expect the whole routes provider:
+	provider router.RoutesProvider
+}
+
+// HandleRequest a silly example which finds routes based only on the first part of the requested path
+// which must be a static one as well, the rest goes to fill the parameters.
+func (r *customRouter) HandleRequest(ctx context.Context) {
+	path := ctx.Path()
+	ctx.Application().Logger().Infof("Requested resource path: %s", path)
+
+	parts := strings.Split(path, "/")[1:]
+	staticPath := "/" + parts[0]
+	for _, route := range r.provider.GetRoutes() {
+		if strings.HasPrefix(route.Path, staticPath) && route.Method == ctx.Method() {
+			paramParts := parts[1:]
+			for _, paramValue := range paramParts {
+				for _, p := range route.Tmpl().Params {
+					ctx.Params().Set(p.Name, paramValue)
+				}
+			}
+
+			ctx.SetCurrentRouteName(route.Name)
+			ctx.Do(route.Handlers)
+			return
+		}
+	}
+
+	// if nothing found...
+	ctx.StatusCode(iris.StatusNotFound)
+}
+
+func (r *customRouter) Build(provider router.RoutesProvider) error {
+	for _, route := range provider.GetRoutes() {
+		// do any necessary validation or conversations based on your custom logic here
+		// but always run the "BuildHandlers" for each registered route.
+		route.BuildHandlers()
+		// [...] r.routes = append(r.routes, *route)
+	}
+
+	r.provider = provider
+	return nil
+}
+
+func (r *customRouter) RouteExists(ctx context.Context, method, path string) bool {
+	// [...]
+	return false
+}
+
+func main() {
+	app := iris.New()
+
+	// In case you are wondering, the parameter types and macros like "{param:string $func()}" still work inside
+	// your custom router if you fetch by the Route's Handler
+	// because they are middlewares under the hood, so you don't have to implement the logic of handling them manually,
+	// though you have to match what requested path is what route and fill the ctx.Params(), this is the work of your custom router.
+	app.Get("/hello/{name}", func(ctx context.Context) {
+		name := ctx.Params().Get("name")
+		ctx.Writef("Hello %s\n", name)
+	})
+
+	app.Get("/cs/{num:uint64 min(10) else 400}", func(ctx context.Context) {
+		num := ctx.Params().GetUint64Default("num", 0)
+		ctx.Writef("num is: %d\n", num)
+	})
+
+	// To replace the existing router with a customized one by using the iris/context.Context
+	// you have to use the `app.BuildRouter` method before `app.Run` and after the routes registered.
+	// You should pass your custom router's instance as the second input arg, which must completes the `router#RequestHandler`
+	// interface as shown above.
+	//
+	// To see how you can build something even more low-level without direct iris' context support (you can do that manually as well)
+	// navigate to the "custom-wrapper" example instead.
+	myCustomRouter := new(customRouter)
+	app.BuildRouter(app.ContextPool, myCustomRouter, app.APIBuilder, true)
+
+	app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
+}

_examples/routing/dynamic-path/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"regexp"
-	"strconv"
 
 	"github.com/kataras/iris"
 )
@@ -14,15 +13,14 @@ func main() {
 	// we've seen static routes, group of routes, subdomains, wildcard subdomains, a small example of parameterized path
 	// with a single known paramete and custom http errors, now it's time to see wildcard parameters and macros.
 
-	// iris, like net/http std package registers route's handlers
+	// Iris, like net/http std package registers route's handlers
 	// by a Handler, the iris' type of handler is just a func(ctx iris.Context)
 	// where context comes from github.com/kataras/iris/context.
-	// Until go 1.9 you will have to import that package too, after go 1.9 this will be not be necessary.
 	//
-	// iris has the easiest and the most powerful routing process you have ever meet.
+	// Iris has the easiest and the most powerful routing process you have ever meet.
 	//
 	// At the same time,
-	// iris has its own interpeter(yes like a programming language)
+	// Iris has its own interpeter(yes like a programming language)
 	// for route's path syntax and their dynamic path parameters parsing and evaluation,
 	// We call them "macros" for shortcut.
 	// How? It calculates its needs and if not any special regexp needed then it just
@@ -36,21 +34,34 @@ func main() {
 	// string type
 	// anything
 	//
-	//  +------------------------+
-	//  | {param:int}            |
-	//  +------------------------+
+	//  +-------------------------------+
+	//  | {param:int} or {param:int} |
+	//  +-------------------------------+
 	// int type
-	// only numbers (0-9)
+	// both positive and negative numbers, any number of digits (ctx.Params().GetInt will limit the digits based on the host arch)
 	//
-	// +------------------------+
-	// | {param:long}           |
-	// +------------------------+
+	// +-------------------------------+
+	// | {param:int64} or {param:long} |
+	// +-------------------------------+
 	// int64 type
-	// only numbers (0-9)
+	// -9223372036854775808 to 9223372036854775807
 	//
 	// +------------------------+
-	// | {param:boolean}        |
+	// | {param:uint8}          |
 	// +------------------------+
+	// uint8 type
+	// 0 to 255
+	//
+	//
+	// +------------------------+
+	// | {param:uint64}         |
+	// +------------------------+
+	// uint64 type
+	// 0 to 18446744073709551615
+	//
+	// +---------------------------------+
+	// | {param:bool} or {param:boolean} |
+	// +---------------------------------+
 	// bool type
 	// only "1" or "t" or "T" or "TRUE" or "true" or "True"
 	// or "0" or "f" or "F" or "FALSE" or "false" or "False"
@@ -89,7 +100,7 @@ func main() {
 	// you are able to register your own too!.
 	//
 	// Register a named path parameter function:
-	// app.Macros().Int.RegisterFunc("min", func(argument int) func(paramValue string) bool {
+	// app.Macros().Number.RegisterFunc("min", func(argument int) func(paramValue string) bool {
 	//  [...]
 	//  return true/false -> true means valid.
 	// })
@@ -107,51 +118,52 @@ func main() {
 		ctx.Writef("Hello %s", ctx.Params().Get("name"))
 	}) // type is missing = {name:string}
 
-	// Let's register our first macro attached to int macro type.
+	// Let's register our first macro attached to uint64 macro type.
 	// "min" = the function
 	// "minValue" = the argument of the function
-	// func(string) bool = the macro's path parameter evaluator, this executes in serve time when
-	// a user requests a path which contains the :int macro type with the min(...) macro parameter function.
-	app.Macros().Int.RegisterFunc("min", func(minValue int) func(string) bool {
-		// do anything before serve here [...]
-		// at this case we don't need to do anything
-		return func(paramValue string) bool {
-			n, err := strconv.Atoi(paramValue)
-			if err != nil {
-				return false
-			}
-			return n >= minValue
+	// func(uint64) bool = our func's evaluator, this executes in serve time when
+	// a user requests a path which contains the :uint64 macro parameter type with the min(...) macro parameter function.
+	app.Macros().Get("uint64").RegisterFunc("min", func(minValue uint64) func(uint64) bool {
+		// type of "paramValue" should match the type of the internal macro's evaluator function, which in this case is "uint64".
+		return func(paramValue uint64) bool {
+			return paramValue >= minValue
 		}
 	})
 
-	// http://localhost:8080/profile/id>=1
+	// http://localhost:8080/profile/id>=20
 	// this will throw 404 even if it's found as route on : /profile/0, /profile/blabla, /profile/-1
 	// macro parameter functions are optional of course.
-	app.Get("/profile/{id:int min(1)}", func(ctx iris.Context) {
+	app.Get("/profile/{id:uint64 min(20)}", func(ctx iris.Context) {
 		// second parameter is the error but it will always nil because we use macros,
 		// the validaton already happened.
-		id, _ := ctx.Params().GetInt("id")
+		id := ctx.Params().GetUint64Default("id", 0)
 		ctx.Writef("Hello id: %d", id)
 	})
 
 	// to change the error code per route's macro evaluator:
-	app.Get("/profile/{id:int min(1)}/friends/{friendid:int min(1) else 504}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt("id")
-		friendid, _ := ctx.Params().GetInt("friendid")
+	app.Get("/profile/{id:uint64 min(1)}/friends/{friendid:uint64 min(1) else 504}", func(ctx iris.Context) {
+		id := ctx.Params().GetUint64Default("id", 0)
+		friendid := ctx.Params().GetUint64Default("friendid", 0)
 		ctx.Writef("Hello id: %d looking for friend id: ", id, friendid)
 	}) // this will throw e 504 error code instead of 404 if all route's macros not passed.
 
-	// Another example using a custom regexp and any custom logic.
+	// :uint8 0 to 255.
+	app.Get("/ages/{age:uint8 else 400}", func(ctx iris.Context) {
+		age, _ := ctx.Params().GetUint8("age")
+		ctx.Writef("age selected: %d", age)
+	})
+
+	// Another example using a custom regexp or any custom logic.
+
+	// Register your custom argument-less macro function to the :string param type.
 	latLonExpr := "^-?[0-9]{1,3}(?:\\.[0-9]{1,10})?$"
 	latLonRegex, err := regexp.Compile(latLonExpr)
 	if err != nil {
 		panic(err)
 	}
 
-	app.Macros().String.RegisterFunc("coordinate", func() func(paramName string) (ok bool) {
-		// MatchString is a type of func(string) bool, so we can return that as it's.
-		return latLonRegex.MatchString
-	})
+	// MatchString is a type of func(string) bool, so we use it as it is.
+	app.Macros().Get("string").RegisterFunc("coordinate", latLonRegex.MatchString)
 
 	app.Get("/coordinates/{lat:string coordinate() else 502}/{lon:string coordinate() else 502}", func(ctx iris.Context) {
 		ctx.Writef("Lat: %s | Lon: %s", ctx.Params().Get("lat"), ctx.Params().Get("lon"))
@@ -159,7 +171,43 @@ func main() {
 
 	//
 
-	// http://localhost:8080/game/a-zA-Z/level/0-9
+	// Another one is by using a custom body.
+	app.Macros().Get("string").RegisterFunc("range", func(minLength, maxLength int) func(string) bool {
+		return func(paramValue string) bool {
+			return len(paramValue) >= minLength && len(paramValue) <= maxLength
+		}
+	})
+
+	app.Get("/limitchar/{name:string range(1,200)}", func(ctx iris.Context) {
+		name := ctx.Params().Get("name")
+		ctx.Writef(`Hello %s | the name should be between 1 and 200 characters length
+		otherwise this handler will not be executed`, name)
+	})
+
+	//
+
+	// Register your custom macro function which accepts a slice of strings `[...,...]`.
+	app.Macros().Get("string").RegisterFunc("has", func(validNames []string) func(string) bool {
+		return func(paramValue string) bool {
+			for _, validName := range validNames {
+				if validName == paramValue {
+					return true
+				}
+			}
+
+			return false
+		}
+	})
+
+	app.Get("/static_validation/{name:string has([kataras,gerasimos,maropoulos]}", func(ctx iris.Context) {
+		name := ctx.Params().Get("name")
+		ctx.Writef(`Hello %s | the name should be "kataras" or "gerasimos" or "maropoulos"
+		otherwise this handler will not be executed`, name)
+	})
+
+	//
+
+	// http://localhost:8080/game/a-zA-Z/level/42
 	// remember, alphabetical is lowercase or uppercase letters only.
 	app.Get("/game/{name:alphabetical}/level/{level:int}", func(ctx iris.Context) {
 		ctx.Writef("name: %s | level: %s", ctx.Params().Get("name"), ctx.Params().Get("level"))
@@ -197,10 +245,9 @@ func main() {
 	// if  "/mypath/{myparam:path}" then the parameter has two names, one is the "*" and the other is the user-defined "myparam".
 
 	// WARNING:
-	// A path parameter name should contain only alphabetical letters. Symbols like  '_' and numbers are NOT allowed.
+	// A path parameter name should contain only alphabetical letters or digits. Symbols like  '_' are NOT allowed.
 	// Last, do not confuse `ctx.Params()` with `ctx.Values()`.
-	// Path parameter's values goes to `ctx.Params()` and context's local storage
-	// that can be used to communicate between handlers and middleware(s) goes to
-	// `ctx.Values()`.
+	// Path parameter's values can be retrieved from `ctx.Params()`,
+	// context's local storage that can be used to communicate between handlers and middleware(s) can be stored to `ctx.Values()`.
 	app.Run(iris.Addr(":8080"))
 }

_examples/routing/macros/main.go

@@ -0,0 +1,76 @@
+// Package main shows how you can register a custom parameter type and macro functions that belongs to it.
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/kataras/iris"
+	"github.com/kataras/iris/context"
+	"github.com/kataras/iris/hero"
+)
+
+func main() {
+	app := iris.New()
+	app.Logger().SetLevel("debug")
+
+	app.Macros().Register("slice", "", false, true, func(paramValue string) (interface{}, bool) {
+		return strings.Split(paramValue, "/"), true
+	}).RegisterFunc("contains", func(expectedItems []string) func(paramValue []string) bool {
+		sort.Strings(expectedItems)
+		return func(paramValue []string) bool {
+			if len(paramValue) != len(expectedItems) {
+				return false
+			}
+
+			sort.Strings(paramValue)
+			for i := 0; i < len(paramValue); i++ {
+				if paramValue[i] != expectedItems[i] {
+					return false
+				}
+			}
+
+			return true
+		}
+	})
+
+	// In order to use your new param type inside MVC controller's function input argument or a hero function input argument
+	// you have to tell the Iris what type it is, the `ValueRaw` of the parameter is the same type
+	// as you defined it above with the func(paramValue string) (interface{}, bool).
+	// The new value and its type(from string to your new custom type) it is stored only once now,
+	// you don't have to do any conversions for simple cases like this.
+	context.ParamResolvers[reflect.TypeOf([]string{})] = func(paramIndex int) interface{} {
+		return func(ctx context.Context) []string {
+			// When you want to retrieve a parameter with a value type that it is not supported by-default, such as ctx.Params().GetInt
+			// then you can use the `GetEntry` or `GetEntryAt` and cast its underline `ValueRaw` to the desired type.
+			// The type should be the same as the macro's evaluator function (last argument on the Macros#Register) return value.
+			return ctx.Params().GetEntryAt(paramIndex).ValueRaw.([]string)
+		}
+	}
+
+	/*
+		http://localhost:8080/test_slice_hero/myvaluei1/myavlue2 ->
+		myparam's value (a trailing path parameter type) is: []string{"myvaluei1", "myavlue2"}
+	*/
+	app.Get("/test_slice_hero/{myparam:slice}", hero.Handler(func(myparam []string) string {
+		return fmt.Sprintf("myparam's value (a trailing path parameter type) is: %#v\n", myparam)
+	}))
+
+	/*
+		http://localhost:8080/test_slice_contains/notcontains1/value2 ->
+		(404) Not Found
+
+		http://localhost:8080/test_slice_contains/value1/value2 ->
+		myparam's value (a trailing path parameter type) is: []string{"value1", "value2"}
+	*/
+	app.Get("/test_slice_contains/{myparam:slice contains([value1,value2])}", func(ctx context.Context) {
+		// When it is not a built'n function available to retrieve your value with the type you want, such as ctx.Params().GetInt
+		// then you can use the `GetEntry.ValueRaw` to get the real value, which is set-ed by your macro above.
+		myparam := ctx.Params().GetEntry("myparam").ValueRaw.([]string)
+		ctx.Writef("myparam's value (a trailing path parameter type) is: %#v\n", myparam)
+	})
+
+	app.Run(iris.Addr(":8080"))
+}

_examples/routing/main.go

@@ -35,25 +35,25 @@ func registerGamesRoutes(app *iris.Application) {
 	{ // braces are optional of course, it's just a style of code
 
 		// "GET" method
-		games.Get("/{gameID:int}/clans", h)
-		games.Get("/{gameID:int}/clans/clan/{clanPublicID:int}", h)
-		games.Get("/{gameID:int}/clans/search", h)
+		games.Get("/{gameID:uint64}/clans", h)
+		games.Get("/{gameID:uint64}/clans/clan/{clanPublicID:uint64}", h)
+		games.Get("/{gameID:uint64}/clans/search", h)
 
 		// "PUT" method
-		games.Put("/{gameID:int}/players/{clanPublicID:int}", h)
-		games.Put("/{gameID:int}/clans/clan/{clanPublicID:int}", h)
+		games.Put("/{gameID:uint64}/players/{clanPublicID:uint64}", h)
+		games.Put("/{gameID:uint64}/clans/clan/{clanPublicID:uint64}", h)
 		// remember: "clanPublicID" should not be changed to other routes with the same prefix.
 		// "POST" method
-		games.Post("/{gameID:int}/clans", h)
-		games.Post("/{gameID:int}/players", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/leave", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/application", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/application/{action}", h) // {action} == {action:string}
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/invitation", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/invitation/{action}", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/delete", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/promote", h)
-		games.Post("/{gameID:int}/clans/{clanPublicID:int}/memberships/demote", h)
+		games.Post("/{gameID:uint64}/clans", h)
+		games.Post("/{gameID:uint64}/players", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/leave", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/application", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/application/{action}", h) // {action} == {action:string}
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/invitation", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/invitation/{action}", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/delete", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/promote", h)
+		games.Post("/{gameID:uint64}/clans/{clanPublicID:uint64}/memberships/demote", h)
 
 		gamesCh := games.Party("/challenge")
 		{

_examples/routing/overview/main.go

@@ -68,8 +68,8 @@ func main() {
 
 	// GET: http://localhost:8080/users/42
 	// **/users/42 and /users/help works after iris version 7.0.5**
-	usersRoutes.Get("/{id:int}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt("id")
+	usersRoutes.Get("/{id:uint64}", func(ctx iris.Context) {
+		id, _ := ctx.Params().GetUint64("id")
 		ctx.Writef("get user by id: %d", id)
 	})
 
@@ -80,15 +80,15 @@ func main() {
 	})
 
 	// PUT: http://localhost:8080/users
-	usersRoutes.Put("/{id:int}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt("id") // or .Get to get its string represatantion.
+	usersRoutes.Put("/{id:uint64}", func(ctx iris.Context) {
+		id, _ := ctx.Params().GetUint64("id") // or .Get to get its string represatantion.
 		username := ctx.PostValue("username")
 		ctx.Writef("update user for id= %d and new username= %s", id, username)
 	})
 
 	// DELETE: http://localhost:8080/users/42
-	usersRoutes.Delete("/{id:int}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt("id")
+	usersRoutes.Delete("/{id:uint64}", func(ctx iris.Context) {
+		id, _ := ctx.Params().GetUint64("id")
 		ctx.Writef("delete user by id: %d", id)
 	})
 

_examples/subdomains/www/main.go

@@ -13,11 +13,11 @@ func newApp() *iris.Application {
 
 	app.PartyFunc("/api/users", func(r iris.Party) {
 		r.Get("/", info)
-		r.Get("/{id:int}", info)
+		r.Get("/{id:uint64}", info)
 
 		r.Post("/", info)
 
-		r.Put("/{id:int}", info)
+		r.Put("/{id:uint64}", info)
 	}) /* <- same as:
 	 usersAPI := app.Party("/api/users")
 	 {  // those brackets are just syntactic-sugar things.

_examples/tutorial/url-shortener/main.go

@@ -2,7 +2,7 @@
 //
 // Article: https://medium.com/@kataras/a-url-shortener-service-using-go-iris-and-bolt-4182f0b00ae7
 //
-// $ go get github.com/coreos/bbolt
+// $ go get github.com/etcd-io/bbolt
 // $ go get github.com/satori/go.uuid
 // $ cd $GOPATH/src/github.com/kataras/iris/_examples/tutorial/url-shortener
 // $ go build

_examples/tutorial/url-shortener/store.go

@@ -3,7 +3,7 @@ package main
 import (
 	"bytes"
 
-	"github.com/coreos/bbolt"
+	bolt "github.com/etcd-io/bbolt"
 )
 
 // Panic panics, change it if you don't want to panic on critical INITIALIZE-ONLY-ERRORS

_examples/tutorial/vuejs-todo-mvc/README.md

@@ -27,7 +27,7 @@ Many articles have been written, in the past, that lead developers not to use a
 You’ll need two dependencies:
 
 1. Vue.js, for our client-side requirements. Download it from [here](https://vuejs.org/), latest v2.
-2. The Iris Web Framework, for our server-side requirements. Can be found [here](https://github.com/kataras/iris), latest v10.
+2. The Iris Web Framework, for our server-side requirements. Can be found [here](https://github.com/kataras/iris), latest v11.
 
 > If you have Go already installed then just execute `go get -u github.com/kataras/iris` to install the Iris Web Framework.
 
@@ -530,7 +530,7 @@ func main() {
     todosApp.Handle(new(controllers.TodoController))
 
     // start the web server at http://localhost:8080
-    app.Run(iris.Addr(":8080"), iris.WithoutVersionChecker)
+    app.Run(iris.Addr(":8080"))
 }
 ```
 

_examples/tutorial/vuejs-todo-mvc/src/web/main.go

@@ -51,5 +51,5 @@ func main() {
 	todosApp.Handle(new(controllers.TodoController))
 
 	// start the web server at http://localhost:8080
-	app.Run(iris.Addr(":8080"), iris.WithoutVersionChecker)
+	app.Run(iris.Addr(":8080"))
 }

_examples/webassembly/basic/client/hello_go111.go

@@ -1,4 +1,4 @@
-// +build go1.11beta3
+// +build js
 
 package main
 
@@ -9,7 +9,7 @@ import (
 )
 
 func main() {
-	// GOARCH=wasm GOOS=js /home/$yourusername/go1.11beta1/bin/go build -o hello.wasm hello_go11beta2.go
+	// GOARCH=wasm GOOS=js /home/$yourusername/go1.11/bin/go build -o hello.wasm hello_go111.go
 	js.Global().Get("console").Call("log", "Hello WebAssemply!")
 	message := fmt.Sprintf("Hello, the current time is: %s", time.Now().String())
 	js.Global().Get("document").Call("getElementById", "hello").Set("innerText", message)

_examples/webassembly/basic/main.go

@@ -6,7 +6,7 @@ import (
 
 /*
 You need to build the hello.wasm first, download the go1.11 and execute the below command:
-$ cd client && GOARCH=wasm GOOS=js /home/$yourname/go1.11beta3/bin/go build -o hello.wasm hello_go11beta3.go
+$ cd client && GOARCH=wasm GOOS=js /home/$yourname/go1.11/bin/go build -o hello.wasm hello_go111.go
 */
 
 func main() {

configuration.go

@@ -222,14 +222,6 @@ var WithoutInterruptHandler = func(app *Application) {
 	app.config.DisableInterruptHandler = true
 }
 
-// WithoutVersionChecker will disable the version checker and updater.
-// The Iris server will be not
-// receive automatic updates if you pass this
-// to the `Run` function. Use it only while you're ready for Production environment.
-var WithoutVersionChecker = func(app *Application) {
-	app.config.DisableVersionChecker = true
-}
-
 // WithoutPathCorrection disables the PathCorrection setting.
 //
 // See `Configuration`.
@@ -388,11 +380,6 @@ type Configuration struct {
 	// Defaults to false.
 	DisableInterruptHandler bool `json:"disableInterruptHandler,omitempty" yaml:"DisableInterruptHandler" toml:"DisableInterruptHandler"`
 
-	// DisableVersionChecker if true then process will be not be notified for any available updates.
-	//
-	// Defaults to false.
-	DisableVersionChecker bool `json:"disableVersionChecker,omitempty" yaml:"DisableVersionChecker" toml:"DisableVersionChecker"`
-
 	// DisablePathCorrection corrects and redirects the requested path to the registered path
 	// for example, if /home/ path is requested but no handler for this Route found,
 	// then the Router checks if /home handler exists, if yes,
@@ -677,10 +664,6 @@ func WithConfiguration(c Configuration) Configurator {
 			main.DisableInterruptHandler = v
 		}
 
-		if v := c.DisableVersionChecker; v {
-			main.DisableVersionChecker = v
-		}
-
 		if v := c.DisablePathCorrection; v {
 			main.DisablePathCorrection = v
 		}
@@ -758,7 +741,6 @@ func DefaultConfiguration() Configuration {
 	return Configuration{
 		DisableStartupLog:                 false,
 		DisableInterruptHandler:           false,
-		DisableVersionChecker:             false,
 		DisablePathCorrection:             false,
 		EnablePathEscape:                  false,
 		FireMethodNotAllowed:              false,

configuration_test.go

@@ -77,13 +77,12 @@ func TestConfigurationOptions(t *testing.T) {
 func TestConfigurationOptionsDeep(t *testing.T) {
 	charset := "MYCHARSET"
 
-	app := New().Configure(WithCharset(charset), WithoutBodyConsumptionOnUnmarshal, WithoutBanner, WithoutVersionChecker)
+	app := New().Configure(WithCharset(charset), WithoutBodyConsumptionOnUnmarshal, WithoutBanner)
 
 	expected := DefaultConfiguration()
 	expected.Charset = charset
 	expected.DisableBodyConsumptionOnUnmarshal = true
 	expected.DisableStartupLog = true
-	expected.DisableVersionChecker = true
 
 	has := *app.config
 
@@ -142,7 +141,6 @@ func TestConfigurationYAML(t *testing.T) {
 	}()
 
 	yamlConfigurationContents := `
-DisableVersionChecker: true
 DisablePathCorrection: false
 EnablePathEscape: false
 FireMethodNotAllowed: true
@@ -165,10 +163,6 @@ Other:
 
 	c := app.config
 
-	if expected := true; c.DisableVersionChecker != expected {
-		t.Fatalf("error on TestConfigurationYAML: Expected DisableVersionChecker %v but got %v", expected, c.DisableVersionChecker)
-	}
-
 	if expected := false; c.DisablePathCorrection != expected {
 		t.Fatalf("error on TestConfigurationYAML: Expected DisablePathCorrection %v but got %v", expected, c.DisablePathCorrection)
 	}
@@ -241,7 +235,6 @@ func TestConfigurationTOML(t *testing.T) {
 	}()
 
 	tomlConfigurationContents := `
-DisableVersionChecker = true
 EnablePathEscape = false
 FireMethodNotAllowed = true
 EnableOptimizations = true
@@ -265,10 +258,6 @@ Charset = "UTF-8"
 
 	c := app.config
 
-	if expected := true; c.DisableVersionChecker != expected {
-		t.Fatalf("error on TestConfigurationTOML: Expected DisableVersionChecker %v but got %v", expected, c.DisableVersionChecker)
-	}
-
 	if expected := false; c.DisablePathCorrection != expected {
 		t.Fatalf("error on TestConfigurationTOML: Expected DisablePathCorrection %v but got %v", expected, c.DisablePathCorrection)
 	}

context/context.go

@@ -76,131 +76,6 @@ func (u UnmarshalerFunc) Unmarshal(data []byte, v interface{}) error {
 	return u(data, v)
 }
 
-// RequestParams is a key string - value string storage which
-// context's request dynamic path params are being kept.
-// Empty if the route is static.
-type RequestParams struct {
-	store memstore.Store
-}
-
-// Set adds a key-value pair to the path parameters values
-// it's being called internally so it shouldn't be used as a local storage by the user, use `ctx.Values()` instead.
-func (r *RequestParams) Set(key, value string) {
-	r.store.Set(key, value)
-}
-
-// Visit accepts a visitor which will be filled
-// by the key-value params.
-func (r *RequestParams) Visit(visitor func(key string, value string)) {
-	r.store.Visit(func(k string, v interface{}) {
-		visitor(k, v.(string)) // always string here.
-	})
-}
-
-var emptyEntry memstore.Entry
-
-// GetEntryAt returns the internal Entry of the memstore based on its index,
-// the stored index by the router.
-// If not found then it returns a zero Entry and false.
-func (r RequestParams) GetEntryAt(index int) (memstore.Entry, bool) {
-	if len(r.store) > index {
-		return r.store[index], true
-	}
-	return emptyEntry, false
-}
-
-// GetEntry returns the internal Entry of the memstore based on its "key".
-// If not found then it returns a zero Entry and false.
-func (r RequestParams) GetEntry(key string) (memstore.Entry, bool) {
-	// we don't return the pointer here, we don't want to give the end-developer
-	// the strength to change the entry that way.
-	if e := r.store.GetEntry(key); e != nil {
-		return *e, true
-	}
-	return emptyEntry, false
-}
-
-// Get returns a path parameter's value based on its route's dynamic path key.
-func (r RequestParams) Get(key string) string {
-	return r.store.GetString(key)
-}
-
-// GetTrim returns a path parameter's value without trailing spaces based on its route's dynamic path key.
-func (r RequestParams) GetTrim(key string) string {
-	return strings.TrimSpace(r.Get(key))
-}
-
-// GetEscape returns a path parameter's double-url-query-escaped value based on its route's dynamic path key.
-func (r RequestParams) GetEscape(key string) string {
-	return DecodeQuery(DecodeQuery(r.Get(key)))
-}
-
-// GetDecoded returns a path parameter's double-url-query-escaped value based on its route's dynamic path key.
-// same as `GetEscape`.
-func (r RequestParams) GetDecoded(key string) string {
-	return r.GetEscape(key)
-}
-
-// GetInt returns the path parameter's value as int, based on its key.
-// It checks for all available types of int, including int64, strings etc.
-// It will return -1 and a non-nil error if parameter wasn't found.
-func (r RequestParams) GetInt(key string) (int, error) {
-	return r.store.GetInt(key)
-}
-
-// GetInt64 returns the path paramete's value as int64, based on its key.
-// It checks for all available types of int, including int, strings etc.
-// It will return -1 and a non-nil error if parameter wasn't found.
-func (r RequestParams) GetInt64(key string) (int64, error) {
-	return r.store.GetInt64(key)
-}
-
-// GetFloat64 returns a path parameter's value based as float64 on its route's dynamic path key.
-// It checks for all available types of int, including float64, int, strings etc.
-// It will return -1 and a non-nil error if parameter wasn't found.
-func (r RequestParams) GetFloat64(key string) (float64, error) {
-	return r.store.GetFloat64(key)
-}
-
-// GetUint64 returns the path paramete's value as uint64, based on its key.
-// It checks for all available types of int, including int, uint64, int64, strings etc.
-// It will return 0 and a non-nil error if parameter wasn't found.
-func (r RequestParams) GetUint64(key string) (uint64, error) {
-	return r.store.GetUint64(key)
-}
-
-// GetBool returns the path parameter's value as bool, based on its key.
-// a string which is "1" or "t" or "T" or "TRUE" or "true" or "True"
-// or "0" or "f" or "F" or "FALSE" or "false" or "False".
-// Any other value returns an error.
-func (r RequestParams) GetBool(key string) (bool, error) {
-	return r.store.GetBool(key)
-}
-
-// GetIntUnslashed same as Get but it removes the first slash if found.
-// Usage: Get an id from a wildcard path.
-//
-// Returns -1 with an error if the parameter couldn't be found.
-func (r RequestParams) GetIntUnslashed(key string) (int, error) {
-	v := r.Get(key)
-	if v != "" {
-		if len(v) > 1 {
-			if v[0] == '/' {
-				v = v[1:]
-			}
-		}
-		return strconv.Atoi(v)
-
-	}
-
-	return -1, fmt.Errorf("unable to find int for '%s'", key)
-}
-
-// Len returns the full length of the parameters.
-func (r RequestParams) Len() int {
-	return r.store.Len()
-}
-
 // Context is the midle-man server's "object" for the clients.
 //
 // A New context is being acquired from a sync.Pool on each connection.
@@ -685,7 +560,8 @@ type Context interface {
 	// Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-xml/main.go
 	ReadXML(xmlObjectPtr interface{}) error
 	// ReadForm binds the formObject  with the form data
-	// it supports any kind of struct.
+	// it supports any kind of type, including custom structs.
+	// It will return nothing if request data are empty.
 	//
 	// Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-form/main.go
 	ReadForm(formObjectPtr interface{}) error
@@ -1116,7 +992,7 @@ func NewContext(app Application) Context {
 func (ctx *context) BeginRequest(w http.ResponseWriter, r *http.Request) {
 	ctx.handlers = nil           // will be filled by router.Serve/HTTP
 	ctx.values = ctx.values[0:0] // >>      >>     by context.Values().Set
-	ctx.params.store = ctx.params.store[0:0]
+	ctx.params.Store = ctx.params.Store[0:0]
 	ctx.request = r
 	ctx.currentHandlerIndex = 0
 	ctx.writer = AcquireResponseWriter()
@@ -2414,17 +2290,15 @@ var (
 	errReadBody = errors.New("while trying to read %s from the request body. Trace %s")
 )
 
-// ErrEmptyForm will be thrown from `context#ReadForm` when empty request data.
-var ErrEmptyForm = errors.New("form data: empty")
-
 // ReadForm binds the formObject  with the form data
-// it supports any kind of struct.
+// it supports any kind of type, including custom structs.
+// It will return nothing if request data are empty.
 //
 // Example: https://github.com/kataras/iris/blob/master/_examples/http_request/read-form/main.go
 func (ctx *context) ReadForm(formObject interface{}) error {
 	values := ctx.FormValues()
-	if values == nil {
-		return ErrEmptyForm
+	if len(values) == 0 {
+		return nil
 	}
 
 	// or dec := formbinder.NewDecoder(&formbinder.DecoderOptions{TagName: "form"})
@@ -2990,12 +2864,10 @@ func (ctx *context) JSON(v interface{}, opts ...JSON) (n int, err error) {
 		options = opts[0]
 	}
 
-	optimize := ctx.shouldOptimize()
-
 	ctx.ContentType(ContentJSONHeaderValue)
 
 	if options.StreamingJSON {
-		if optimize {
+		if ctx.shouldOptimize() {
 			var jsoniterConfig = jsoniter.Config{
 				EscapeHTML:    !options.UnescapeHTML,
 				IndentionStep: 4,
@@ -3016,7 +2888,7 @@ func (ctx *context) JSON(v interface{}, opts ...JSON) (n int, err error) {
 		return ctx.writer.Written(), err
 	}
 
-	n, err = WriteJSON(ctx.writer, v, options, optimize)
+	n, err = WriteJSON(ctx.writer, v, options, ctx.shouldOptimize())
 	if err != nil {
 		ctx.StatusCode(http.StatusInternalServerError)
 		return 0, err

context/request_params.go

@@ -0,0 +1,206 @@
+package context
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/kataras/iris/core/memstore"
+)
+
+// RequestParams is a key string - value string storage which
+// context's request dynamic path params are being kept.
+// Empty if the route is static.
+type RequestParams struct {
+	memstore.Store
+}
+
+// Set inserts a value to the key-value storage.
+//
+// See `SetImmutable` and `Get` too.
+func (r *RequestParams) Set(key, value string) {
+	r.Store.Set(key, value)
+}
+
+// GetEntryAt will return the parameter's internal store's `Entry` based on the index.
+// If not found it will return an emptry `Entry`.
+func (r *RequestParams) GetEntryAt(index int) memstore.Entry {
+	entry, _ := r.Store.GetEntryAt(index)
+	return entry
+}
+
+// GetEntry will return the parameter's internal store's `Entry` based on its name/key.
+// If not found it will return an emptry `Entry`.
+func (r *RequestParams) GetEntry(key string) memstore.Entry {
+	entry, _ := r.Store.GetEntry(key)
+	return entry
+}
+
+// Visit accepts a visitor which will be filled
+// by the key-value params.
+func (r *RequestParams) Visit(visitor func(key string, value string)) {
+	r.Store.Visit(func(k string, v interface{}) {
+		visitor(k, fmt.Sprintf("%v", v)) // always string here.
+	})
+}
+
+// Get returns a path parameter's value based on its route's dynamic path key.
+func (r RequestParams) Get(key string) string {
+	return r.GetString(key)
+}
+
+// GetTrim returns a path parameter's value without trailing spaces based on its route's dynamic path key.
+func (r RequestParams) GetTrim(key string) string {
+	return strings.TrimSpace(r.Get(key))
+}
+
+// GetEscape returns a path parameter's double-url-query-escaped value based on its route's dynamic path key.
+func (r RequestParams) GetEscape(key string) string {
+	return DecodeQuery(DecodeQuery(r.Get(key)))
+}
+
+// GetDecoded returns a path parameter's double-url-query-escaped value based on its route's dynamic path key.
+// same as `GetEscape`.
+func (r RequestParams) GetDecoded(key string) string {
+	return r.GetEscape(key)
+}
+
+// GetIntUnslashed same as Get but it removes the first slash if found.
+// Usage: Get an id from a wildcard path.
+//
+// Returns -1 and false if not path parameter with that "key" found.
+func (r RequestParams) GetIntUnslashed(key string) (int, bool) {
+	v := r.Get(key)
+	if v != "" {
+		if len(v) > 1 {
+			if v[0] == '/' {
+				v = v[1:]
+			}
+		}
+
+		vInt, err := strconv.Atoi(v)
+		if err != nil {
+			return -1, false
+		}
+		return vInt, true
+	}
+
+	return -1, false
+}
+
+var (
+	// ParamResolvers is the global param resolution for a parameter type for a specific go std or custom type.
+	//
+	// Key is the specific type, which should be unique.
+	// The value is a function which accepts the parameter index
+	// and it should return the value as the parameter type evaluator expects it.
+	// i.e [reflect.TypeOf("string")] = func(paramIndex int) interface{} {
+	//     return func(ctx Context) <T> {
+	//         return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(<T>)
+	//     }
+	// }
+	//
+	// Read https://github.com/kataras/iris/tree/master/_examples/routing/macros for more details.
+	ParamResolvers = map[reflect.Type]func(paramIndex int) interface{}{
+		reflect.TypeOf(""): func(paramIndex int) interface{} {
+			return func(ctx Context) string {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(string)
+			}
+		},
+		reflect.TypeOf(int(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) int {
+				// v, _ := ctx.Params().GetEntryAt(paramIndex).IntDefault(0)
+				// return v
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(int)
+			}
+		},
+		reflect.TypeOf(int8(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) int8 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(int8)
+			}
+		},
+		reflect.TypeOf(int16(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) int16 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(int16)
+			}
+		},
+		reflect.TypeOf(int32(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) int32 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(int32)
+			}
+		},
+		reflect.TypeOf(int64(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) int64 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(int64)
+			}
+		},
+		reflect.TypeOf(uint(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) uint {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint)
+			}
+		},
+		reflect.TypeOf(uint8(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) uint8 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint8)
+			}
+		},
+		reflect.TypeOf(uint16(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) uint16 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint16)
+			}
+		},
+		reflect.TypeOf(uint32(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) uint32 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint32)
+			}
+		},
+		reflect.TypeOf(uint64(1)): func(paramIndex int) interface{} {
+			return func(ctx Context) uint64 {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint64)
+			}
+		},
+		reflect.TypeOf(true): func(paramIndex int) interface{} {
+			return func(ctx Context) bool {
+				return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(bool)
+			}
+		},
+	}
+)
+
+// ParamResolverByTypeAndIndex will return a function that can be used to bind path parameter's exact value by its Go std type
+// and the parameter's index based on the registered path.
+// Usage: nameResolver := ParamResolverByKindAndKey(reflect.TypeOf(""), 0)
+// Inside a Handler:      nameResolver.Call(ctx)[0]
+//        it will return the reflect.Value Of the exact type of the parameter(based on the path parameters and macros).
+// It is only useful for dynamic binding of the parameter, it is used on "hero" package and it should be modified
+// only when Macros are modified in such way that the default selections for the available go std types are not enough.
+//
+// Returns empty value and false if "k" does not match any valid parameter resolver.
+func ParamResolverByTypeAndIndex(typ reflect.Type, paramIndex int) (reflect.Value, bool) {
+	/* NO:
+	// This could work but its result is not exact type, so direct binding is not possible.
+	resolver := m.ParamResolver
+	fn := func(ctx context.Context) interface{} {
+		entry, _ := ctx.Params().GetEntry(paramName)
+		return resolver(entry)
+	}
+	//
+
+	// This works but it is slower on serve-time.
+	paramNameValue := []reflect.Value{reflect.ValueOf(paramName)}
+	var fnSignature func(context.Context) string
+	return reflect.MakeFunc(reflect.ValueOf(&fnSignature).Elem().Type(), func(in []reflect.Value) []reflect.Value {
+		return in[0].MethodByName("Params").Call(emptyIn)[0].MethodByName("Get").Call(paramNameValue)
+		// return []reflect.Value{reflect.ValueOf(in[0].Interface().(context.Context).Params().Get(paramName))}
+	})
+	//
+	*/
+
+	r, ok := ParamResolvers[typ]
+	if !ok || r == nil {
+		return reflect.Value{}, false
+	}
+
+	return reflect.ValueOf(r(paramIndex)), true
+}

context/route.go

@@ -1,6 +1,6 @@
 package context
 
-import "github.com/kataras/iris/core/router/macro"
+import "github.com/kataras/iris/macro"
 
 // RouteReadOnly allows decoupled access to the current route
 // inside the context.
@@ -25,7 +25,7 @@ type RouteReadOnly interface {
 
 	// StaticPath returns the static part of the original, registered route path.
 	// if /user/{id} it will return /user
-	// if /user/{id}/friend/{friendid:int} it will return /user too
+	// if /user/{id}/friend/{friendid:uint64} it will return /user too
 	// if /assets/{filepath:path} it will return /assets.
 	StaticPath() string
 

core/host/proxy_test.go

@@ -60,7 +60,7 @@ func TestProxy(t *testing.T) {
 		t.Fatalf("%v while creating tcp4 listener for new tls local test listener", err)
 	}
 	// main server
-	go app.Run(iris.Listener(httptest.NewLocalTLSListener(l)), iris.WithoutVersionChecker, iris.WithoutStartupLog)
+	go app.Run(iris.Listener(httptest.NewLocalTLSListener(l)), iris.WithoutStartupLog)
 
 	e := httptest.NewInsecure(t, httptest.URL("http://"+listener.Addr().String()))
 	e.GET("/").Expect().Status(iris.StatusOK).Body().Equal(expectedIndex)

core/maintenance/maintenance.go

@@ -1,6 +0,0 @@
-package maintenance
-
-// Start starts the maintenance process.
-func Start() {
-	CheckForUpdates()
-}

core/maintenance/version.go

@@ -1,78 +0,0 @@
-package maintenance
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-
-	"github.com/kataras/iris/core/maintenance/version"
-
-	"github.com/kataras/golog"
-	"github.com/kataras/survey"
-)
-
-const (
-	// Version is the string representation of the current local Iris Web Framework version.
-	Version = "10.7.0"
-)
-
-// CheckForUpdates checks for any available updates
-// and asks for the user if want to update now or not.
-func CheckForUpdates() {
-	v := version.Acquire()
-	updateAvailale := v.Compare(Version) == version.Smaller
-
-	if updateAvailale {
-		if confirmUpdate(v) {
-			installVersion()
-			return
-		}
-	}
-}
-
-func confirmUpdate(v version.Version) bool {
-	// on help? when asking for installing the new update.
-	ignoreUpdatesMsg := "Would you like to ignore future updates? Disable the version checker via:\napp.Run(..., iris.WithoutVersionChecker)"
-
-	// if update available ask for update action.
-	shouldUpdateNowMsg :=
-		fmt.Sprintf("A new version is available online[%s > %s]. Type '?' for help.\nRelease notes: %s.\nUpdate now?",
-			v.String(), Version, v.ChangelogURL)
-
-	var confirmUpdate bool
-	survey.AskOne(&survey.Confirm{
-		Message: shouldUpdateNowMsg,
-		Help:    ignoreUpdatesMsg,
-	}, &confirmUpdate, nil)
-	return confirmUpdate // it's true only when update was available and user typed "yes".
-}
-
-func installVersion() {
-	golog.Infof("Downloading...\n")
-	repo := "github.com/kataras/iris/..."
-	cmd := exec.Command("go", "get", "-u", "-v", repo)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stdout
-
-	if err := cmd.Run(); err != nil {
-		golog.Warnf("unexpected message while trying to go get,\nif you edited the original source code then you've to remove the whole $GOPATH/src/github.com/kataras folder and execute `go get -u github.com/kataras/iris/...` manually\n%v", err)
-		return
-	}
-
-	golog.Infof("Update process finished.\nManual rebuild and restart is required to apply the changes...\n")
-	return
-}
-
-/* Author's note:
-We could use github webhooks to automatic notify for updates
-when a new update is pushed to the repository
-even when server is already started and running but this would expose
-a route which dev may don't know about, so let it for now but if
-they ask it then I should add an optional configuration field
-to "live/realtime update" and implement the idea (which is already implemented in the iris-go server).
-*/
-
-/* Author's note:
-The old remote endpoint for version checker is still available on the server for backwards
-compatibility with older clients, it will stay there for a long period of time.
-*/

core/maintenance/version/fetch.go

@@ -1,59 +0,0 @@
-package version
-
-import (
-	"io/ioutil"
-	"strings"
-	"time"
-
-	"github.com/hashicorp/go-version"
-
-	"github.com/kataras/golog"
-	"github.com/kataras/iris/core/netutil"
-)
-
-const (
-	versionURL = "https://raw.githubusercontent.com/kataras/iris/master/VERSION"
-)
-
-func fetch() (*version.Version, string) {
-	client := netutil.Client(time.Duration(30 * time.Second))
-
-	r, err := client.Get(versionURL)
-	if err != nil {
-		golog.Debugf("err: %v\n", err)
-		return nil, ""
-	}
-	defer r.Body.Close()
-
-	if r.StatusCode >= 400 {
-		golog.Debugf("Internet connection is missing, updater is unable to fetch the latest Iris version\n%v", err)
-		return nil, ""
-	}
-
-	b, err := ioutil.ReadAll(r.Body)
-
-	if len(b) == 0 || err != nil {
-		golog.Debugf("err: %v\n", err)
-		return nil, ""
-	}
-
-	var (
-		fetchedVersion = string(b)
-		changelogURL   string
-	)
-	// Example output:
-	// Version(8.5.5)
-	// 8.5.5:https://github.com/kataras/iris/blob/master/HISTORY.md#tu-02-november-2017--v855
-	if idx := strings.IndexByte(fetchedVersion, ':'); idx > 0 {
-		changelogURL = fetchedVersion[idx+1:]
-		fetchedVersion = fetchedVersion[0:idx]
-	}
-
-	latestVersion, err := version.NewVersion(fetchedVersion)
-	if err != nil {
-		golog.Debugf("while fetching and parsing latest version from github: %v\n", err)
-		return nil, ""
-	}
-
-	return latestVersion, changelogURL
-}

core/maintenance/version/version.go

@@ -1,64 +0,0 @@
-package version
-
-import (
-	"time"
-
-	"github.com/hashicorp/go-version"
-)
-
-// Version is a version wrapper which
-// contains some additional customized properties.
-type Version struct {
-	version.Version
-	WrittenAt    time.Time
-	ChangelogURL string
-}
-
-// Result is the compare result type.
-// Available types are Invalid, Smaller, Equal or Larger.
-type Result int32
-
-const (
-	// Smaller when the compared version is smaller than the latest one.
-	Smaller Result = -1
-	// Equal when the compared version is equal with the latest one.
-	Equal Result = 0
-	// Larger when the compared version is larger than the latest one.
-	Larger Result = 1
-	// Invalid means that an error occurred when comparing the versions.
-	Invalid Result = -2
-)
-
-// Compare compares the "versionStr" with the latest Iris version,
-// opossite to the version package
-// it returns the result of the "versionStr" not the "v" itself.
-func (v *Version) Compare(versionStr string) Result {
-	if len(v.Version.String()) == 0 {
-		// if version not refreshed, by an internet connection lose,
-		// then return Invalid.
-		return Invalid
-	}
-
-	other, err := version.NewVersion(versionStr)
-	if err != nil {
-		return Invalid
-	}
-	return Result(other.Compare(&v.Version))
-}
-
-// Acquire returns the latest version info wrapper.
-// It calls the fetch.
-func Acquire() (v Version) {
-	newVersion, changelogURL := fetch()
-	if newVersion == nil { // if github was down then don't panic, just set it as the smallest version.
-		newVersion, _ = version.NewVersion("0.0.1")
-	}
-
-	v = Version{
-		Version:      *newVersion,
-		WrittenAt:    time.Now(),
-		ChangelogURL: changelogURL,
-	}
-
-	return
-}

core/memstore/memstore.go

@@ -6,6 +6,8 @@
 package memstore
 
 import (
+	"fmt"
+	"math"
 	"reflect"
 	"strconv"
 	"strings"
@@ -14,6 +16,11 @@ import (
 )
 
 type (
+	// ValueSetter is the interface which can be accepted as a generic solution of RequestParams or memstore when Set is the only requirement,
+	// i.e internally on macro/template/TemplateParam#Eval:paramChanger.
+	ValueSetter interface {
+		Set(key string, newValue interface{}) (Entry, bool)
+	}
 	// Entry is the entry of the context storage Store - .Values()
 	Entry struct {
 		Key       string
@@ -25,6 +32,8 @@ type (
 	Store []Entry
 )
 
+var _ ValueSetter = (*Store)(nil)
+
 // GetByKindOrNil will try to get this entry's value of "k" kind,
 // if value is not that kind it will NOT try to convert it the "k", instead
 // it will return nil, except if boolean; then it will return false
@@ -67,11 +76,19 @@ func (e Entry) GetByKindOrNil(k reflect.Kind) interface{} {
 // If not found returns "def".
 func (e Entry) StringDefault(def string) string {
 	v := e.ValueRaw
+	if v == nil {
+		return def
+	}
 
 	if vString, ok := v.(string); ok {
 		return vString
 	}
 
+	val := fmt.Sprintf("%v", v)
+	if val != "" {
+		return val
+	}
+
 	return def
 }
 
@@ -94,20 +111,129 @@ func (e Entry) IntDefault(def int) (int, error) {
 	if v == nil {
 		return def, errFindParse.Format("int", e.Key)
 	}
-	if vint, ok := v.(int); ok {
-		return vint, nil
-	} else if vstring, sok := v.(string); sok && vstring != "" {
-		vint, err := strconv.Atoi(vstring)
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.Atoi(vv)
 		if err != nil {
 			return def, err
 		}
-
-		return vint, nil
+		return val, nil
+	case int:
+		return vv, nil
+	case int8:
+		return int(vv), nil
+	case int16:
+		return int(vv), nil
+	case int32:
+		return int(vv), nil
+	case int64:
+		return int(vv), nil
+	case uint:
+		return int(vv), nil
+	case uint8:
+		return int(vv), nil
+	case uint16:
+		return int(vv), nil
+	case uint32:
+		return int(vv), nil
+	case uint64:
+		return int(vv), nil
 	}
 
 	return def, errFindParse.Format("int", e.Key)
 }
 
+// Int8Default returns the entry's value as int8.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Int8Default(def int8) (int8, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("int8", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseInt(vv, 10, 8)
+		if err != nil {
+			return def, err
+		}
+		return int8(val), nil
+	case int:
+		return int8(vv), nil
+	case int8:
+		return vv, nil
+	case int16:
+		return int8(vv), nil
+	case int32:
+		return int8(vv), nil
+	case int64:
+		return int8(vv), nil
+	}
+
+	return def, errFindParse.Format("int8", e.Key)
+}
+
+// Int16Default returns the entry's value as int16.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Int16Default(def int16) (int16, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("int16", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseInt(vv, 10, 16)
+		if err != nil {
+			return def, err
+		}
+		return int16(val), nil
+	case int:
+		return int16(vv), nil
+	case int8:
+		return int16(vv), nil
+	case int16:
+		return vv, nil
+	case int32:
+		return int16(vv), nil
+	case int64:
+		return int16(vv), nil
+	}
+
+	return def, errFindParse.Format("int16", e.Key)
+}
+
+// Int32Default returns the entry's value as int32.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Int32Default(def int32) (int32, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("int32", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseInt(vv, 10, 32)
+		if err != nil {
+			return def, err
+		}
+		return int32(val), nil
+	case int:
+		return int32(vv), nil
+	case int8:
+		return int32(vv), nil
+	case int16:
+		return int32(vv), nil
+	case int32:
+		return vv, nil
+	case int64:
+		return int32(vv), nil
+	}
+
+	return def, errFindParse.Format("int32", e.Key)
+}
+
 // Int64Default returns the entry's value as int64.
 // If not found returns "def" and a non-nil error.
 func (e Entry) Int64Default(def int64) (int64, error) {
@@ -116,85 +242,208 @@ func (e Entry) Int64Default(def int64) (int64, error) {
 		return def, errFindParse.Format("int64", e.Key)
 	}
 
-	if vint64, ok := v.(int64); ok {
-		return vint64, nil
-	}
-
-	if vint, ok := v.(int); ok {
-		return int64(vint), nil
-	}
-
-	if vstring, sok := v.(string); sok {
-		return strconv.ParseInt(vstring, 10, 64)
+	switch vv := v.(type) {
+	case string:
+		return strconv.ParseInt(vv, 10, 64)
+	case int64:
+		return vv, nil
+	case int32:
+		return int64(vv), nil
+	case int8:
+		return int64(vv), nil
+	case int:
+		return int64(vv), nil
 	}
 
 	return def, errFindParse.Format("int64", e.Key)
 }
 
-// Float64Default returns the entry's value as float64.
+// UintDefault returns the entry's value as uint.
 // If not found returns "def" and a non-nil error.
-func (e Entry) Float64Default(def float64) (float64, error) {
+func (e Entry) UintDefault(def uint) (uint, error) {
 	v := e.ValueRaw
-
 	if v == nil {
-		return def, errFindParse.Format("float64", e.Key)
+		return def, errFindParse.Format("uint", e.Key)
 	}
 
-	if vfloat32, ok := v.(float32); ok {
-		return float64(vfloat32), nil
+	x64 := strconv.IntSize == 64
+	var maxValue uint = math.MaxUint32
+	if x64 {
+		maxValue = math.MaxUint64
 	}
 
-	if vfloat64, ok := v.(float64); ok {
-		return vfloat64, nil
-	}
-
-	if vint, ok := v.(int); ok {
-		return float64(vint), nil
-	}
-
-	if vstring, sok := v.(string); sok {
-		vfloat64, err := strconv.ParseFloat(vstring, 64)
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseUint(vv, 10, strconv.IntSize)
 		if err != nil {
 			return def, err
 		}
-
-		return vfloat64, nil
+		if val > uint64(maxValue) {
+			return def, errFindParse.Format("uint", e.Key)
+		}
+		return uint(val), nil
+	case uint:
+		return vv, nil
+	case uint8:
+		return uint(vv), nil
+	case uint16:
+		return uint(vv), nil
+	case uint32:
+		return uint(vv), nil
+	case uint64:
+		if vv > uint64(maxValue) {
+			return def, errFindParse.Format("uint", e.Key)
+		}
+		return uint(vv), nil
+	case int:
+		if vv < 0 || vv > int(maxValue) {
+			return def, errFindParse.Format("uint", e.Key)
+		}
+		return uint(vv), nil
 	}
 
-	return def, errFindParse.Format("float64", e.Key)
+	return def, errFindParse.Format("uint", e.Key)
 }
 
-// Float32Default returns the entry's value as float32.
+// Uint8Default returns the entry's value as uint8.
 // If not found returns "def" and a non-nil error.
-func (e Entry) Float32Default(key string, def float32) (float32, error) {
+func (e Entry) Uint8Default(def uint8) (uint8, error) {
 	v := e.ValueRaw
-
 	if v == nil {
-		return def, errFindParse.Format("float32", e.Key)
+		return def, errFindParse.Format("uint8", e.Key)
 	}
 
-	if vfloat32, ok := v.(float32); ok {
-		return vfloat32, nil
-	}
-
-	if vfloat64, ok := v.(float64); ok {
-		return float32(vfloat64), nil
-	}
-
-	if vint, ok := v.(int); ok {
-		return float32(vint), nil
-	}
-
-	if vstring, sok := v.(string); sok {
-		vfloat32, err := strconv.ParseFloat(vstring, 32)
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseUint(vv, 10, 8)
 		if err != nil {
 			return def, err
 		}
-
-		return float32(vfloat32), nil
+		if val > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(val), nil
+	case uint:
+		if vv > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(vv), nil
+	case uint8:
+		return vv, nil
+	case uint16:
+		if vv > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(vv), nil
+	case uint32:
+		if vv > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(vv), nil
+	case uint64:
+		if vv > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(vv), nil
+	case int:
+		if vv < 0 || vv > math.MaxUint8 {
+			return def, errFindParse.Format("uint8", e.Key)
+		}
+		return uint8(vv), nil
 	}
 
-	return def, errFindParse.Format("float32", e.Key)
+	return def, errFindParse.Format("uint8", e.Key)
+}
+
+// Uint16Default returns the entry's value as uint16.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Uint16Default(def uint16) (uint16, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("uint16", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseUint(vv, 10, 16)
+		if err != nil {
+			return def, err
+		}
+		if val > math.MaxUint16 {
+			return def, errFindParse.Format("uint16", e.Key)
+		}
+		return uint16(val), nil
+	case uint:
+		if vv > math.MaxUint16 {
+			return def, errFindParse.Format("uint16", e.Key)
+		}
+		return uint16(vv), nil
+	case uint8:
+		return uint16(vv), nil
+	case uint16:
+		return vv, nil
+	case uint32:
+		if vv > math.MaxUint16 {
+			return def, errFindParse.Format("uint16", e.Key)
+		}
+		return uint16(vv), nil
+	case uint64:
+		if vv > math.MaxUint16 {
+			return def, errFindParse.Format("uint16", e.Key)
+		}
+		return uint16(vv), nil
+	case int:
+		if vv < 0 || vv > math.MaxUint16 {
+			return def, errFindParse.Format("uint16", e.Key)
+		}
+		return uint16(vv), nil
+	}
+
+	return def, errFindParse.Format("uint16", e.Key)
+}
+
+// Uint32Default returns the entry's value as uint32.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Uint32Default(def uint32) (uint32, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("uint32", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseUint(vv, 10, 32)
+		if err != nil {
+			return def, err
+		}
+		if val > math.MaxUint32 {
+			return def, errFindParse.Format("uint32", e.Key)
+		}
+		return uint32(val), nil
+	case uint:
+		if vv > math.MaxUint32 {
+			return def, errFindParse.Format("uint32", e.Key)
+		}
+		return uint32(vv), nil
+	case uint8:
+		return uint32(vv), nil
+	case uint16:
+		return uint32(vv), nil
+	case uint32:
+		return vv, nil
+	case uint64:
+		if vv > math.MaxUint32 {
+			return def, errFindParse.Format("uint32", e.Key)
+		}
+		return uint32(vv), nil
+	case int:
+		if vv < 0 || vv > math.MaxUint32 {
+			return def, errFindParse.Format("uint32", e.Key)
+		}
+		return uint32(vv), nil
+	}
+
+	return def, errFindParse.Format("uint32", e.Key)
 }
 
 // Uint64Default returns the entry's value as uint64.
@@ -205,25 +454,102 @@ func (e Entry) Uint64Default(def uint64) (uint64, error) {
 		return def, errFindParse.Format("uint64", e.Key)
 	}
 
-	if vuint64, ok := v.(uint64); ok {
-		return vuint64, nil
-	}
-
-	if vint64, ok := v.(int64); ok {
-		return uint64(vint64), nil
-	}
-
-	if vint, ok := v.(int); ok {
-		return uint64(vint), nil
-	}
-
-	if vstring, sok := v.(string); sok {
-		return strconv.ParseUint(vstring, 10, 64)
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseUint(vv, 10, 64)
+		if err != nil {
+			return def, err
+		}
+		if val > math.MaxUint64 {
+			return def, errFindParse.Format("uint64", e.Key)
+		}
+		return uint64(val), nil
+	case uint:
+		if vv > math.MaxUint64 {
+			return def, errFindParse.Format("uint64", e.Key)
+		}
+		return uint64(vv), nil
+	case uint8:
+		return uint64(vv), nil
+	case uint16:
+		return uint64(vv), nil
+	case uint32:
+		return uint64(vv), nil
+	case uint64:
+		return vv, nil
+	case int64:
+		return uint64(vv), nil
+	case int:
+		return uint64(vv), nil
 	}
 
 	return def, errFindParse.Format("uint64", e.Key)
 }
 
+// Float32Default returns the entry's value as float32.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Float32Default(key string, def float32) (float32, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("float32", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseFloat(vv, 32)
+		if err != nil {
+			return def, err
+		}
+		if val > math.MaxFloat32 {
+			return def, errFindParse.Format("float32", e.Key)
+		}
+		return float32(val), nil
+	case float32:
+		return vv, nil
+	case float64:
+		if vv > math.MaxFloat32 {
+			return def, errFindParse.Format("float32", e.Key)
+		}
+		return float32(vv), nil
+	case int:
+		return float32(vv), nil
+	}
+
+	return def, errFindParse.Format("float32", e.Key)
+}
+
+// Float64Default returns the entry's value as float64.
+// If not found returns "def" and a non-nil error.
+func (e Entry) Float64Default(def float64) (float64, error) {
+	v := e.ValueRaw
+	if v == nil {
+		return def, errFindParse.Format("float64", e.Key)
+	}
+
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseFloat(vv, 64)
+		if err != nil {
+			return def, err
+		}
+		return val, nil
+	case float32:
+		return float64(vv), nil
+	case float64:
+		return vv, nil
+	case int:
+		return float64(vv), nil
+	case int64:
+		return float64(vv), nil
+	case uint:
+		return float64(vv), nil
+	case uint64:
+		return float64(vv), nil
+	}
+
+	return def, errFindParse.Format("float64", e.Key)
+}
+
 // BoolDefault returns the user's value as bool.
 // a string which is "1" or "t" or "T" or "TRUE" or "true" or "True"
 // or "0" or "f" or "F" or "FALSE" or "false" or "False".
@@ -236,20 +562,17 @@ func (e Entry) BoolDefault(def bool) (bool, error) {
 		return def, errFindParse.Format("bool", e.Key)
 	}
 
-	if vBoolean, ok := v.(bool); ok {
-		return vBoolean, nil
-	}
-
-	if vString, ok := v.(string); ok {
-		b, err := strconv.ParseBool(vString)
+	switch vv := v.(type) {
+	case string:
+		val, err := strconv.ParseBool(vv)
 		if err != nil {
 			return def, err
 		}
-		return b, nil
-	}
-
-	if vInt, ok := v.(int); ok {
-		if vInt == 1 {
+		return val, nil
+	case bool:
+		return vv, nil
+	case int:
+		if vv == 1 {
 			return true, nil
 		}
 		return false, nil
@@ -361,28 +684,39 @@ func (r *Store) SetImmutable(key string, value interface{}) (Entry, bool) {
 	return r.Save(key, value, true)
 }
 
+var emptyEntry Entry
+
 // GetEntry returns a pointer to the "Entry" found with the given "key"
-// if nothing found then it returns nil, so be careful with that,
-// it's not supposed to be used by end-developers.
-func (r *Store) GetEntry(key string) *Entry {
+// if nothing found then it returns an empty Entry and false.
+func (r *Store) GetEntry(key string) (Entry, bool) {
 	args := *r
 	n := len(args)
 	for i := 0; i < n; i++ {
-		kv := &args[i]
-		if kv.Key == key {
-			return kv
+		if kv := args[i]; kv.Key == key {
+			return kv, true
 		}
 	}
 
-	return nil
+	return emptyEntry, false
+}
+
+// GetEntryAt returns the internal Entry of the memstore based on its index,
+// the stored index by the router.
+// If not found then it returns a zero Entry and false.
+func (r *Store) GetEntryAt(index int) (Entry, bool) {
+	args := *r
+	if len(args) > index {
+		return args[index], true
+	}
+	return emptyEntry, false
 }
 
 // GetDefault returns the entry's value based on its key.
 // If not found returns "def".
 // This function checks for immutability as well, the rest don't.
 func (r *Store) GetDefault(key string, def interface{}) interface{} {
-	v := r.GetEntry(key)
-	if v == nil || v.ValueRaw == nil {
+	v, ok := r.GetEntry(key)
+	if !ok || v.ValueRaw == nil {
 		return def
 	}
 	vv := v.Value()
@@ -411,8 +745,8 @@ func (r *Store) Visit(visitor func(key string, value interface{})) {
 // GetStringDefault returns the entry's value as string, based on its key.
 // If not found returns "def".
 func (r *Store) GetStringDefault(key string, def string) string {
-	v := r.GetEntry(key)
-	if v == nil {
+	v, ok := r.GetEntry(key)
+	if !ok {
 		return def
 	}
 
@@ -432,8 +766,8 @@ func (r *Store) GetStringTrim(name string) string {
 // GetInt returns the entry's value as int, based on its key.
 // If not found returns -1 and a non-nil error.
 func (r *Store) GetInt(key string) (int, error) {
-	v := r.GetEntry(key)
-	if v == nil {
+	v, ok := r.GetEntry(key)
+	if !ok {
 		return 0, errFindParse.Format("int", key)
 	}
 	return v.IntDefault(-1)
@@ -449,20 +783,60 @@ func (r *Store) GetIntDefault(key string, def int) int {
 	return def
 }
 
-// GetUint64 returns the entry's value as uint64, based on its key.
-// If not found returns 0 and a non-nil error.
-func (r *Store) GetUint64(key string) (uint64, error) {
-	v := r.GetEntry(key)
-	if v == nil {
-		return 0, errFindParse.Format("uint64", key)
+// GetInt8 returns the entry's value as int8, based on its key.
+// If not found returns -1 and a non-nil error.
+func (r *Store) GetInt8(key string) (int8, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return -1, errFindParse.Format("int8", key)
 	}
-	return v.Uint64Default(0)
+	return v.Int8Default(-1)
 }
 
-// GetUint64Default returns the entry's value as uint64, based on its key.
+// GetInt8Default returns the entry's value as int8, based on its key.
 // If not found returns "def".
-func (r *Store) GetUint64Default(key string, def uint64) uint64 {
-	if v, err := r.GetUint64(key); err == nil {
+func (r *Store) GetInt8Default(key string, def int8) int8 {
+	if v, err := r.GetInt8(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetInt16 returns the entry's value as int16, based on its key.
+// If not found returns -1 and a non-nil error.
+func (r *Store) GetInt16(key string) (int16, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return -1, errFindParse.Format("int16", key)
+	}
+	return v.Int16Default(-1)
+}
+
+// GetInt16Default returns the entry's value as int16, based on its key.
+// If not found returns "def".
+func (r *Store) GetInt16Default(key string, def int16) int16 {
+	if v, err := r.GetInt16(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetInt32 returns the entry's value as int32, based on its key.
+// If not found returns -1 and a non-nil error.
+func (r *Store) GetInt32(key string) (int32, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return -1, errFindParse.Format("int32", key)
+	}
+	return v.Int32Default(-1)
+}
+
+// GetInt32Default returns the entry's value as int32, based on its key.
+// If not found returns "def".
+func (r *Store) GetInt32Default(key string, def int32) int32 {
+	if v, err := r.GetInt32(key); err == nil {
 		return v
 	}
 
@@ -472,8 +846,8 @@ func (r *Store) GetUint64Default(key string, def uint64) uint64 {
 // GetInt64 returns the entry's value as int64, based on its key.
 // If not found returns -1 and a non-nil error.
 func (r *Store) GetInt64(key string) (int64, error) {
-	v := r.GetEntry(key)
-	if v == nil {
+	v, ok := r.GetEntry(key)
+	if !ok {
 		return -1, errFindParse.Format("int64", key)
 	}
 	return v.Int64Default(-1)
@@ -489,11 +863,111 @@ func (r *Store) GetInt64Default(key string, def int64) int64 {
 	return def
 }
 
+// GetUint returns the entry's value as uint, based on its key.
+// If not found returns 0 and a non-nil error.
+func (r *Store) GetUint(key string) (uint, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return 0, errFindParse.Format("uint", key)
+	}
+	return v.UintDefault(0)
+}
+
+// GetUintDefault returns the entry's value as uint, based on its key.
+// If not found returns "def".
+func (r *Store) GetUintDefault(key string, def uint) uint {
+	if v, err := r.GetUint(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetUint8 returns the entry's value as uint8, based on its key.
+// If not found returns 0 and a non-nil error.
+func (r *Store) GetUint8(key string) (uint8, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return 0, errFindParse.Format("uint8", key)
+	}
+	return v.Uint8Default(0)
+}
+
+// GetUint8Default returns the entry's value as uint8, based on its key.
+// If not found returns "def".
+func (r *Store) GetUint8Default(key string, def uint8) uint8 {
+	if v, err := r.GetUint8(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetUint16 returns the entry's value as uint16, based on its key.
+// If not found returns 0 and a non-nil error.
+func (r *Store) GetUint16(key string) (uint16, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return 0, errFindParse.Format("uint16", key)
+	}
+	return v.Uint16Default(0)
+}
+
+// GetUint16Default returns the entry's value as uint16, based on its key.
+// If not found returns "def".
+func (r *Store) GetUint16Default(key string, def uint16) uint16 {
+	if v, err := r.GetUint16(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetUint32 returns the entry's value as uint32, based on its key.
+// If not found returns 0 and a non-nil error.
+func (r *Store) GetUint32(key string) (uint32, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return 0, errFindParse.Format("uint32", key)
+	}
+	return v.Uint32Default(0)
+}
+
+// GetUint32Default returns the entry's value as uint32, based on its key.
+// If not found returns "def".
+func (r *Store) GetUint32Default(key string, def uint32) uint32 {
+	if v, err := r.GetUint32(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
+// GetUint64 returns the entry's value as uint64, based on its key.
+// If not found returns 0 and a non-nil error.
+func (r *Store) GetUint64(key string) (uint64, error) {
+	v, ok := r.GetEntry(key)
+	if !ok {
+		return 0, errFindParse.Format("uint64", key)
+	}
+	return v.Uint64Default(0)
+}
+
+// GetUint64Default returns the entry's value as uint64, based on its key.
+// If not found returns "def".
+func (r *Store) GetUint64Default(key string, def uint64) uint64 {
+	if v, err := r.GetUint64(key); err == nil {
+		return v
+	}
+
+	return def
+}
+
 // GetFloat64 returns the entry's value as float64, based on its key.
 // If not found returns -1 and a non nil error.
 func (r *Store) GetFloat64(key string) (float64, error) {
-	v := r.GetEntry(key)
-	if v == nil {
+	v, ok := r.GetEntry(key)
+	if !ok {
 		return -1, errFindParse.Format("float64", key)
 	}
 	return v.Float64Default(-1)
@@ -516,8 +990,8 @@ func (r *Store) GetFloat64Default(key string, def float64) float64 {
 //
 // If not found returns false and a non-nil error.
 func (r *Store) GetBool(key string) (bool, error) {
-	v := r.GetEntry(key)
-	if v == nil {
+	v, ok := r.GetEntry(key)
+	if !ok {
 		return false, errFindParse.Format("bool", key)
 	}
 

core/router/api_builder.go

@@ -9,20 +9,18 @@ import (
 
 	"github.com/kataras/iris/context"
 	"github.com/kataras/iris/core/errors"
-	"github.com/kataras/iris/core/router/macro"
+	"github.com/kataras/iris/macro"
 )
 
-const (
-	// MethodNone is a Virtual method
-	// to store the "offline" routes.
-	MethodNone = "NONE"
-)
+// MethodNone is a Virtual method
+// to store the "offline" routes.
+const MethodNone = "NONE"
 
 var (
 	// AllMethods contains the valid http methods:
 	// "GET", "POST", "PUT", "DELETE", "CONNECT", "HEAD",
 	// "PATCH", "OPTIONS", "TRACE".
-	AllMethods = [...]string{
+	AllMethods = []string{
 		"GET",
 		"POST",
 		"PUT",
@@ -68,7 +66,7 @@ func (r *repository) getAll() []*Route {
 // and child routers.
 type APIBuilder struct {
 	// the api builder global macros registry
-	macros *macro.Map
+	macros *macro.Macros
 	// the api builder global handlers per status code registry (used for custom http errors)
 	errorCodeHandlers *ErrorCodeHandlers
 	// the api builder global routes repository
@@ -116,7 +114,7 @@ var _ RoutesProvider = (*APIBuilder)(nil) // passed to the default request handl
 // which is responsible to build the API and the router handler.
 func NewAPIBuilder() *APIBuilder {
 	api := &APIBuilder{
-		macros:            defaultMacros(),
+		macros:            macro.Defaults,
 		errorCodeHandlers: defaultErrorCodeHandlers(),
 		reporter:          errors.NewReporter(),
 		relativePath:      "/",
@@ -246,7 +244,7 @@ func (api *APIBuilder) Handle(method string, relativePath string, handlers ...co
 	)
 
 	for _, m := range methods {
-		route, err = NewRoute(m, subdomain, path, possibleMainHandlerName, routeHandlers, api.macros)
+		route, err = NewRoute(m, subdomain, path, possibleMainHandlerName, routeHandlers, *api.macros)
 		if err != nil { // template path parser errors:
 			api.reporter.Add("%v -> %s:%s:%s", err, method, subdomain, path)
 			return nil // fail on first error.
@@ -270,10 +268,10 @@ func (api *APIBuilder) Handle(method string, relativePath string, handlers ...co
 // otherwise use `Party` which can handle many paths with different handlers and middlewares.
 //
 // Usage:
-// 	app.HandleMany("GET", "/user /user/{id:int} /user/me", genericUserHandler)
+// 	app.HandleMany("GET", "/user /user/{id:uint64} /user/me", genericUserHandler)
 // At the other side, with `Handle` we've had to write:
 // 	app.Handle("GET", "/user", userHandler)
-// 	app.Handle("GET", "/user/{id:int}", userByIDHandler)
+// 	app.Handle("GET", "/user/{id:uint64}", userByIDHandler)
 // 	app.Handle("GET", "/user/me", userMeHandler)
 //
 // This method is used behind the scenes at the `Controller` function
@@ -411,11 +409,11 @@ func (api *APIBuilder) WildcardSubdomain(middleware ...context.Handler) Party {
 	return api.Subdomain(SubdomainWildcardIndicator, middleware...)
 }
 
-// Macros returns the macro map which is responsible
-// to register custom macro functions for all routes.
+// Macros returns the macro collection that is responsible
+// to register custom macros with their own parameter types and their macro functions for all routes.
 //
 // Learn more at:  https://github.com/kataras/iris/tree/master/_examples/routing/dynamic-path
-func (api *APIBuilder) Macros() *macro.Map {
+func (api *APIBuilder) Macros() *macro.Macros {
 	return api.macros
 }
 

core/router/handler.go

@@ -11,40 +11,30 @@ import (
 	"github.com/kataras/iris/context"
 	"github.com/kataras/iris/core/errors"
 	"github.com/kataras/iris/core/netutil"
-	"github.com/kataras/iris/core/router/node"
 )
 
 // RequestHandler the middle man between acquiring a context and releasing it.
 // By-default is the router algorithm.
 type RequestHandler interface {
-	// HandleRequest is same as context.Handler but its usage is only about routing,
-	// separate the concept here.
+	// HandleRequest should handle the request based on the Context.
 	HandleRequest(context.Context)
-	// Build  should builds the handler, it's being called on router's BuildRouter.
+	// Build should builds the handler, it's being called on router's BuildRouter.
 	Build(provider RoutesProvider) error
 	// RouteExists reports whether a particular route exists.
 	RouteExists(ctx context.Context, method, path string) bool
 }
 
-type tree struct {
-	Method string
-	// subdomain is empty for default-hostname routes,
-	// ex: mysubdomain.
-	Subdomain string
-	Nodes     *node.Nodes
-}
-
 type routerHandler struct {
-	trees []*tree
+	trees []*trie
 	hosts bool // true if at least one route contains a Subdomain.
 }
 
 var _ RequestHandler = &routerHandler{}
 
-func (h *routerHandler) getTree(method, subdomain string) *tree {
+func (h *routerHandler) getTree(method, subdomain string) *trie {
 	for i := range h.trees {
 		t := h.trees[i]
-		if t.Method == method && t.Subdomain == subdomain {
+		if t.method == method && t.subdomain == subdomain {
 			return t
 		}
 	}
@@ -64,12 +54,14 @@ func (h *routerHandler) addRoute(r *Route) error {
 	t := h.getTree(method, subdomain)
 
 	if t == nil {
-		n := node.Nodes{}
+		n := newTrieNode()
 		// first time we register a route to this method with this subdomain
-		t = &tree{Method: method, Subdomain: subdomain, Nodes: &n}
+		t = &trie{method: method, subdomain: subdomain, root: n}
 		h.trees = append(h.trees, t)
 	}
-	return t.Nodes.Add(routeName, path, handlers)
+
+	t.insert(path, routeName, handlers)
+	return nil
 }
 
 // NewDefaultHandler returns the handler which is responsible
@@ -189,11 +181,11 @@ func (h *routerHandler) HandleRequest(ctx context.Context) {
 
 	for i := range h.trees {
 		t := h.trees[i]
-		if method != t.Method {
+		if method != t.method {
 			continue
 		}
 
-		if h.hosts && t.Subdomain != "" {
+		if h.hosts && t.subdomain != "" {
 			requestHost := ctx.Host()
 			if netutil.IsLoopbackSubdomain(requestHost) {
 				// this fixes a bug when listening on
@@ -202,7 +194,7 @@ func (h *routerHandler) HandleRequest(ctx context.Context) {
 				continue // it's not a subdomain, it's something like 127.0.0.1 probably
 			}
 			// it's a dynamic wildcard subdomain, we have just to check if ctx.subdomain is not empty
-			if t.Subdomain == SubdomainWildcardIndicator {
+			if t.subdomain == SubdomainWildcardIndicator {
 				// mydomain.com -> invalid
 				// localhost -> invalid
 				// sub.mydomain.com -> valid
@@ -220,14 +212,14 @@ func (h *routerHandler) HandleRequest(ctx context.Context) {
 					continue
 				}
 				// continue to that, any subdomain is valid.
-			} else if !strings.HasPrefix(requestHost, t.Subdomain) { // t.Subdomain contains the dot.
+			} else if !strings.HasPrefix(requestHost, t.subdomain) { // t.subdomain contains the dot.
 				continue
 			}
 		}
-		routeName, handlers := t.Nodes.Find(path, ctx.Params())
-		if len(handlers) > 0 {
-			ctx.SetCurrentRouteName(routeName)
-			ctx.Do(handlers)
+		n := t.search(path, ctx.Params())
+		if n != nil {
+			ctx.SetCurrentRouteName(n.RouteName)
+			ctx.Do(n.Handlers)
 			// found
 			return
 		}
@@ -238,15 +230,12 @@ func (h *routerHandler) HandleRequest(ctx context.Context) {
 	if ctx.Application().ConfigurationReadOnly().GetFireMethodNotAllowed() {
 		for i := range h.trees {
 			t := h.trees[i]
-			// a bit slower than previous implementation but @kataras let me to apply this change
-			// because it's more reliable.
-			//
 			// if `Configuration#FireMethodNotAllowed` is kept as defaulted(false) then this function will not
 			// run, therefore performance kept as before.
-			if t.Nodes.Exists(path) {
+			if h.subdomainAndPathAndMethodExists(ctx, t, "", path) {
 				// RCF rfc2616 https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
 				// The response MUST include an Allow header containing a list of valid methods for the requested resource.
-				ctx.Header("Allow", t.Method)
+				ctx.Header("Allow", t.method)
 				ctx.StatusCode(http.StatusMethodNotAllowed)
 				return
 			}
@@ -256,55 +245,55 @@ func (h *routerHandler) HandleRequest(ctx context.Context) {
 	ctx.StatusCode(http.StatusNotFound)
 }
 
+func (h *routerHandler) subdomainAndPathAndMethodExists(ctx context.Context, t *trie, method, path string) bool {
+	if method != "" && method != t.method {
+		return false
+	}
+
+	if h.hosts && t.subdomain != "" {
+		requestHost := ctx.Host()
+		if netutil.IsLoopbackSubdomain(requestHost) {
+			// this fixes a bug when listening on
+			// 127.0.0.1:8080 for example
+			// and have a wildcard subdomain and a route registered to root domain.
+			return false // it's not a subdomain, it's something like 127.0.0.1 probably
+		}
+		// it's a dynamic wildcard subdomain, we have just to check if ctx.subdomain is not empty
+		if t.subdomain == SubdomainWildcardIndicator {
+			// mydomain.com -> invalid
+			// localhost -> invalid
+			// sub.mydomain.com -> valid
+			// sub.localhost -> valid
+			serverHost := ctx.Application().ConfigurationReadOnly().GetVHost()
+			if serverHost == requestHost {
+				return false // it's not a subdomain, it's a full domain (with .com...)
+			}
+
+			dotIdx := strings.IndexByte(requestHost, '.')
+			slashIdx := strings.IndexByte(requestHost, '/')
+			if dotIdx > 0 && (slashIdx == -1 || slashIdx > dotIdx) {
+				// if "." was found anywhere but not at the first path segment (host).
+			} else {
+				return false
+			}
+			// continue to that, any subdomain is valid.
+		} else if !strings.HasPrefix(requestHost, t.subdomain) { // t.subdomain contains the dot.
+			return false
+		}
+	}
+
+	n := t.search(path, ctx.Params())
+	return n != nil
+}
+
 // RouteExists reports whether a particular route exists
 // It will search from the current subdomain of context's host, if not inside the root domain.
 func (h *routerHandler) RouteExists(ctx context.Context, method, path string) bool {
 	for i := range h.trees {
 		t := h.trees[i]
-		if method != t.Method {
-			continue
-		}
-
-		if h.hosts && t.Subdomain != "" {
-			requestHost := ctx.Host()
-			if netutil.IsLoopbackSubdomain(requestHost) {
-				// this fixes a bug when listening on
-				// 127.0.0.1:8080 for example
-				// and have a wildcard subdomain and a route registered to root domain.
-				continue // it's not a subdomain, it's something like 127.0.0.1 probably
-			}
-			// it's a dynamic wildcard subdomain, we have just to check if ctx.subdomain is not empty
-			if t.Subdomain == SubdomainWildcardIndicator {
-				// mydomain.com -> invalid
-				// localhost -> invalid
-				// sub.mydomain.com -> valid
-				// sub.localhost -> valid
-				serverHost := ctx.Application().ConfigurationReadOnly().GetVHost()
-				if serverHost == requestHost {
-					continue // it's not a subdomain, it's a full domain (with .com...)
-				}
-
-				dotIdx := strings.IndexByte(requestHost, '.')
-				slashIdx := strings.IndexByte(requestHost, '/')
-				if dotIdx > 0 && (slashIdx == -1 || slashIdx > dotIdx) {
-					// if "." was found anywhere but not at the first path segment (host).
-				} else {
-					continue
-				}
-				// continue to that, any subdomain is valid.
-			} else if !strings.HasPrefix(requestHost, t.Subdomain) { // t.Subdomain contains the dot.
-				continue
-			}
-		}
-
-		_, handlers := t.Nodes.Find(path, ctx.Params())
-		if len(handlers) > 0 {
-			// found
+		if h.subdomainAndPathAndMethodExists(ctx, t, method, path) {
 			return true
 		}
-
-		// not found or method not allowed.
-		break
 	}
 
 	return false

core/router/macro.go

@@ -1,253 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/kataras/iris/context"
-	"github.com/kataras/iris/core/errors"
-	"github.com/kataras/iris/core/router/macro"
-	"github.com/kataras/iris/core/router/macro/interpreter/ast"
-)
-
-// defaultMacros returns a new macro map which
-// contains the default router's named param types functions.
-func defaultMacros() *macro.Map {
-	macros := macro.NewMap()
-	// registers the String and Int default macro funcs
-	// user can add or override of his own funcs later on
-	// i.e:
-	// app.Macro.String.RegisterFunc("equal", func(eqWith string) func(string) bool {
-	//	return func(paramValue string) bool {
-	//	   return eqWith == paramValue
-	//  }})
-	registerBuiltinsMacroFuncs(macros)
-
-	return macros
-}
-
-func registerBuiltinsMacroFuncs(out *macro.Map) {
-	// register the String which is the default type if not
-	// parameter type is specified or
-	// if a given parameter into path given but the func doesn't exist on the
-	// parameter type's function list.
-	//
-	// these can be overridden by the user, later on.
-	registerStringMacroFuncs(out.String)
-	registerIntMacroFuncs(out.Int)
-	registerIntMacroFuncs(out.Long)
-	registerAlphabeticalMacroFuncs(out.Alphabetical)
-	registerFileMacroFuncs(out.File)
-	registerPathMacroFuncs(out.Path)
-}
-
-// String
-// anything one part
-func registerStringMacroFuncs(out *macro.Macro) {
-	// this can be used everywhere, it's to help users to define custom regexp expressions
-	// on all macros
-	out.RegisterFunc("regexp", func(expr string) macro.EvaluatorFunc {
-		regexpEvaluator := macro.MustNewEvaluatorFromRegexp(expr)
-		return regexpEvaluator
-	})
-
-	// checks if param value starts with the 'prefix' arg
-	out.RegisterFunc("prefix", func(prefix string) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			return strings.HasPrefix(paramValue, prefix)
-		}
-	})
-
-	// checks if param value ends with the 'suffix' arg
-	out.RegisterFunc("suffix", func(suffix string) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			return strings.HasSuffix(paramValue, suffix)
-		}
-	})
-
-	// checks if param value contains the 's' arg
-	out.RegisterFunc("contains", func(s string) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			return strings.Contains(paramValue, s)
-		}
-	})
-
-	// checks if param value's length is at least 'min'
-	out.RegisterFunc("min", func(min int) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			return len(paramValue) >= min
-		}
-	})
-	// checks if param value's length is not bigger than 'max'
-	out.RegisterFunc("max", func(max int) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			return max >= len(paramValue)
-		}
-	})
-}
-
-// Int
-// only numbers (0-9)
-func registerIntMacroFuncs(out *macro.Macro) {
-	// checks if the param value's int representation is
-	// bigger or equal than 'min'
-	out.RegisterFunc("min", func(min int) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			n, err := strconv.Atoi(paramValue)
-			if err != nil {
-				return false
-			}
-			return n >= min
-		}
-	})
-
-	// checks if the param value's int representation is
-	// smaller or equal than 'max'
-	out.RegisterFunc("max", func(max int) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			n, err := strconv.Atoi(paramValue)
-			if err != nil {
-				return false
-			}
-			return n <= max
-		}
-	})
-
-	// checks if the param value's int representation is
-	// between min and max, including 'min' and 'max'
-	out.RegisterFunc("range", func(min, max int) macro.EvaluatorFunc {
-		return func(paramValue string) bool {
-			n, err := strconv.Atoi(paramValue)
-			if err != nil {
-				return false
-			}
-
-			if n < min || n > max {
-				return false
-			}
-			return true
-		}
-	})
-}
-
-// Alphabetical
-// letters only (upper or lowercase)
-func registerAlphabeticalMacroFuncs(out *macro.Macro) {
-
-}
-
-// File
-// letters (upper or lowercase)
-// numbers (0-9)
-// underscore (_)
-// dash (-)
-// point (.)
-// no spaces! or other character
-func registerFileMacroFuncs(out *macro.Macro) {
-
-}
-
-// Path
-// File+slashes(anywhere)
-// should be the latest param, it's the wildcard
-func registerPathMacroFuncs(out *macro.Macro) {
-
-}
-
-// compileRoutePathAndHandlers receives a route info and returns its parsed/"compiled" path
-// and the new handlers (prepend all the macro's handler, if any).
-//
-// It's not exported for direct use.
-func compileRoutePathAndHandlers(handlers context.Handlers, tmpl *macro.Template) (string, context.Handlers, error) {
-	// parse the path to node's path, now.
-	path, err := convertTmplToNodePath(tmpl)
-	if err != nil {
-		return tmpl.Src, handlers, err
-	}
-	// prepend the macro handler to the route, now,
-	// right before the register to the tree, so routerbuilder.UseGlobal will work as expected.
-	if len(tmpl.Params) > 0 {
-		macroEvaluatorHandler := convertTmplToHandler(tmpl)
-		// may return nil if no really need a macro handler evaluator
-		if macroEvaluatorHandler != nil {
-			handlers = append(context.Handlers{macroEvaluatorHandler}, handlers...)
-		}
-	}
-
-	return path, handlers, nil
-}
-
-func convertTmplToNodePath(tmpl *macro.Template) (string, error) {
-	routePath := tmpl.Src
-	if len(tmpl.Params) > 0 {
-		if routePath[len(routePath)-1] == '/' {
-			routePath = routePath[0 : len(routePath)-2] // remove the last "/" if macro syntax instead of underline's
-		}
-	}
-
-	// if it has started with {} and it's valid
-	// then the tmpl.Params will be filled,
-	// so no any further check needed
-	for i, p := range tmpl.Params {
-		if p.Type == ast.ParamTypePath {
-			if i != len(tmpl.Params)-1 {
-				return "", errors.New("parameter type \"ParamTypePath\" should be putted to the very last of a path")
-			}
-			routePath = strings.Replace(routePath, p.Src, WildcardParam(p.Name), 1)
-		} else {
-			routePath = strings.Replace(routePath, p.Src, Param(p.Name), 1)
-		}
-	}
-
-	return routePath, nil
-}
-
-// note: returns nil if not needed, the caller(router) should be check for that before adding that on route's Middleware
-func convertTmplToHandler(tmpl *macro.Template) context.Handler {
-
-	needMacroHandler := false
-
-	// check if we have params like: {name:string} or {name} or {anything:path} without else keyword or any functions used inside these params.
-	// 1. if we don't have, then we don't need to add a handler before the main route's handler (as I said, no performance if macro is not really used)
-	// 2. if we don't have any named params then we don't need a handler too.
-	for _, p := range tmpl.Params {
-		if len(p.Funcs) == 0 && (p.Type == ast.ParamTypeUnExpected || p.Type == ast.ParamTypeString || p.Type == ast.ParamTypePath) && p.ErrCode == http.StatusNotFound {
-		} else {
-			// println("we need handler for: " + tmpl.Src)
-			needMacroHandler = true
-		}
-	}
-
-	if !needMacroHandler {
-		// println("we don't need handler for: " + tmpl.Src)
-		return nil
-	}
-
-	return func(tmpl macro.Template) context.Handler {
-		return func(ctx context.Context) {
-			for _, p := range tmpl.Params {
-				paramValue := ctx.Params().Get(p.Name)
-				// first, check for type evaluator
-				if !p.TypeEvaluator(paramValue) {
-					ctx.StatusCode(p.ErrCode)
-					ctx.StopExecution()
-					return
-				}
-
-				// then check for all of its functions
-				for _, evalFunc := range p.Funcs {
-					if !evalFunc(paramValue) {
-						ctx.StatusCode(p.ErrCode)
-						ctx.StopExecution()
-						return
-					}
-				}
-
-			}
-			// if all passed, just continue
-			ctx.Next()
-		}
-	}(*tmpl)
-
-}

core/router/macro/interpreter/ast/ast.go

@@ -1,215 +0,0 @@
-package ast
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-)
-
-// ParamType is a specific uint8 type
-// which holds the parameter types' type.
-type ParamType uint8
-
-const (
-	// ParamTypeUnExpected is an unexpected parameter type.
-	ParamTypeUnExpected ParamType = iota
-	// ParamTypeString 	is the string type.
-	// If parameter type is missing then it defaults to String type.
-	// Allows anything
-	// Declaration: /mypath/{myparam:string} or /mypath{myparam}
-	ParamTypeString
-	// ParamTypeInt is the integer, a number type.
-	// Allows only positive numbers (0-9)
-	// Declaration: /mypath/{myparam:int}
-	ParamTypeInt
-	// ParamTypeLong is the integer, a number type.
-	// Allows only positive numbers (0-9)
-	// Declaration: /mypath/{myparam:long}
-	ParamTypeLong
-	// ParamTypeBoolean is the bool type.
-	// Allows only "1" or "t" or "T" or "TRUE" or "true" or "True"
-	// or "0" or "f" or "F" or "FALSE" or "false" or "False".
-	// Declaration: /mypath/{myparam:boolean}
-	ParamTypeBoolean
-	// ParamTypeAlphabetical is the  alphabetical/letter type type.
-	// Allows letters only (upper or lowercase)
-	// Declaration:  /mypath/{myparam:alphabetical}
-	ParamTypeAlphabetical
-	// ParamTypeFile  is the file single path type.
-	// Allows:
-	// letters (upper or lowercase)
-	// numbers (0-9)
-	// underscore (_)
-	// dash (-)
-	// point (.)
-	// no spaces! or other character
-	// Declaration: /mypath/{myparam:file}
-	ParamTypeFile
-	// ParamTypePath is the multi path (or wildcard) type.
-	// Allows anything, should be the last part
-	// Declaration: /mypath/{myparam:path}
-	ParamTypePath
-)
-
-func (pt ParamType) String() string {
-	for k, v := range paramTypes {
-		if v == pt {
-			return k
-		}
-	}
-
-	return "unexpected"
-}
-
-// Not because for a single reason
-// a string may be a
-// ParamTypeString or a ParamTypeFile
-// or a ParamTypePath or ParamTypeAlphabetical.
-//
-// func ParamTypeFromStd(k reflect.Kind) ParamType {
-
-// Kind returns the std kind of this param type.
-func (pt ParamType) Kind() reflect.Kind {
-	switch pt {
-	case ParamTypeAlphabetical:
-		fallthrough
-	case ParamTypeFile:
-		fallthrough
-	case ParamTypePath:
-		fallthrough
-	case ParamTypeString:
-		return reflect.String
-	case ParamTypeInt:
-		return reflect.Int
-	case ParamTypeLong:
-		return reflect.Int64
-	case ParamTypeBoolean:
-		return reflect.Bool
-	}
-	return reflect.Invalid // 0
-}
-
-// ValidKind will return true if at least one param type is supported
-// for this std kind.
-func ValidKind(k reflect.Kind) bool {
-	switch k {
-	case reflect.String:
-		fallthrough
-	case reflect.Int:
-		fallthrough
-	case reflect.Int64:
-		fallthrough
-	case reflect.Bool:
-		return true
-	default:
-		return false
-	}
-}
-
-// Assignable returns true if the "k" standard type
-// is assignabled to this ParamType.
-func (pt ParamType) Assignable(k reflect.Kind) bool {
-	return pt.Kind() == k
-}
-
-var paramTypes = map[string]ParamType{
-	"string":       ParamTypeString,
-	"int":          ParamTypeInt,
-	"long":         ParamTypeLong,
-	"boolean":      ParamTypeBoolean,
-	"alphabetical": ParamTypeAlphabetical,
-	"file":         ParamTypeFile,
-	"path":         ParamTypePath,
-	// could be named also:
-	// "tail":
-	// "wild"
-	// "wildcard"
-
-}
-
-// LookupParamType accepts the string
-// representation of a parameter type.
-// Available:
-// "string"
-// "int"
-// "long"
-// "alphabetical"
-// "file"
-// "path"
-func LookupParamType(ident string) ParamType {
-	if typ, ok := paramTypes[ident]; ok {
-		return typ
-	}
-	return ParamTypeUnExpected
-}
-
-// LookupParamTypeFromStd accepts the string representation of a standard go type.
-// It returns a ParamType, but it may differs for example
-// the alphabetical, file, path and string are all string go types, so
-// make sure that caller resolves these types before this call.
-//
-// string matches to string
-// int matches to int
-// int64 matches to long
-// bool matches to boolean
-func LookupParamTypeFromStd(goType string) ParamType {
-	switch goType {
-	case "string":
-		return ParamTypeString
-	case "int":
-		return ParamTypeInt
-	case "int64":
-		return ParamTypeLong
-	case "bool":
-		return ParamTypeBoolean
-	default:
-		return ParamTypeUnExpected
-	}
-}
-
-// ParamStatement is a struct
-// which holds all the necessary information about a macro parameter.
-// It holds its type (string, int, alphabetical, file, path),
-// its source ({param:type}),
-// its name ("param"),
-// its attached functions by the user (min, max...)
-// and the http error code if that parameter
-// failed to be evaluated.
-type ParamStatement struct {
-	Src       string      // the original unparsed source, i.e: {id:int range(1,5) else 404}
-	Name      string      // id
-	Type      ParamType   // int
-	Funcs     []ParamFunc // range
-	ErrorCode int         // 404
-}
-
-// ParamFuncArg represents a single parameter function's argument
-type ParamFuncArg interface{}
-
-// ParamFuncArgToInt converts and returns
-// any type of "a", to an integer.
-func ParamFuncArgToInt(a ParamFuncArg) (int, error) {
-	switch a.(type) {
-	case int:
-		return a.(int), nil
-	case string:
-		return strconv.Atoi(a.(string))
-	case int64:
-		return int(a.(int64)), nil
-	default:
-		return -1, fmt.Errorf("unexpected function argument type: %q", a)
-	}
-}
-
-// ParamFunc holds the name of a parameter's function
-// and its arguments (values)
-// A param func is declared with:
-// {param:int range(1,5)},
-// the range is the
-// param function name
-// the 1 and 5 are the two param function arguments
-// range(1,5)
-type ParamFunc struct {
-	Name string         // range
-	Args []ParamFuncArg // [1,5]
-}

core/router/macro/macro.go

@@ -1,292 +0,0 @@
-package macro
-
-import (
-	"fmt"
-	"reflect"
-	"regexp"
-	"strconv"
-	"unicode"
-
-	"github.com/kataras/iris/core/router/macro/interpreter/ast"
-)
-
-// EvaluatorFunc is the signature for both param types and param funcs.
-// It should accepts the param's value as string
-// and return true if validated otherwise false.
-type EvaluatorFunc func(paramValue string) bool
-
-// NewEvaluatorFromRegexp accepts a regexp "expr" expression
-// and returns an EvaluatorFunc based on that regexp.
-// the regexp is compiled before return.
-//
-// Returns a not-nil error on regexp compile failure.
-func NewEvaluatorFromRegexp(expr string) (EvaluatorFunc, error) {
-	if expr == "" {
-		return nil, fmt.Errorf("empty regex expression")
-	}
-
-	// add the last $ if missing (and not wildcard(?))
-	if i := expr[len(expr)-1]; i != '$' && i != '*' {
-		expr += "$"
-	}
-
-	r, err := regexp.Compile(expr)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.MatchString, nil
-}
-
-// MustNewEvaluatorFromRegexp same as NewEvaluatorFromRegexp
-// but it panics on the "expr" parse failure.
-func MustNewEvaluatorFromRegexp(expr string) EvaluatorFunc {
-	r, err := NewEvaluatorFromRegexp(expr)
-	if err != nil {
-		panic(err)
-	}
-	return r
-}
-
-var (
-	goodParamFuncReturnType  = reflect.TypeOf(func(string) bool { return false })
-	goodParamFuncReturnType2 = reflect.TypeOf(EvaluatorFunc(func(string) bool { return false }))
-)
-
-func goodParamFunc(typ reflect.Type) bool {
-	// should be a func
-	// which returns a func(string) bool
-	if typ.Kind() == reflect.Func {
-		if typ.NumOut() == 1 {
-			typOut := typ.Out(0)
-			if typOut == goodParamFuncReturnType || typOut == goodParamFuncReturnType2 {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-// goodParamFuncName reports whether the function name is a valid identifier.
-func goodParamFuncName(name string) bool {
-	if name == "" {
-		return false
-	}
-	// valid names are only letters and _
-	for _, r := range name {
-		switch {
-		case r == '_':
-		case !unicode.IsLetter(r):
-			return false
-		}
-	}
-	return true
-}
-
-// the convertBuilderFunc return value is generating at boot time.
-// convertFunc converts an interface to a valid full param function.
-func convertBuilderFunc(fn interface{}) ParamEvaluatorBuilder {
-
-	typFn := reflect.TypeOf(fn)
-	if !goodParamFunc(typFn) {
-		return nil
-	}
-
-	numFields := typFn.NumIn()
-
-	return func(args []ast.ParamFuncArg) EvaluatorFunc {
-		if len(args) != numFields {
-			// no variadics support, for now.
-			panic("args should be the same len as numFields")
-		}
-		var argValues []reflect.Value
-		for i := 0; i < numFields; i++ {
-			field := typFn.In(i)
-			arg := args[i]
-
-			if field.Kind() != reflect.TypeOf(arg).Kind() {
-				panic("fields should have the same type")
-			}
-
-			argValues = append(argValues, reflect.ValueOf(arg))
-		}
-
-		evalFn := reflect.ValueOf(fn).Call(argValues)[0].Interface()
-
-		var evaluator EvaluatorFunc
-		// check for typed and not typed
-		if _v, ok := evalFn.(EvaluatorFunc); ok {
-			evaluator = _v
-		} else if _v, ok = evalFn.(func(string) bool); ok {
-			evaluator = _v
-		}
-		return func(paramValue string) bool {
-			return evaluator(paramValue)
-		}
-	}
-}
-
-type (
-	// Macro represents the parsed macro,
-	// which holds
-	// the evaluator (param type's evaluator + param functions evaluators)
-	// and its param functions.
-	//
-	// Any type contains its own macro
-	// instance, so an String type
-	// contains its type evaluator
-	// which is the "Evaluator" field
-	// and it can register param functions
-	// to that macro which maps to a parameter type.
-	Macro struct {
-		Evaluator EvaluatorFunc
-		funcs     []ParamFunc
-	}
-
-	// ParamEvaluatorBuilder is a func
-	// which accepts a param function's arguments (values)
-	// and returns an EvaluatorFunc, its job
-	// is to make the macros to be registered
-	// by user at the most generic possible way.
-	ParamEvaluatorBuilder func([]ast.ParamFuncArg) EvaluatorFunc
-
-	// ParamFunc represents the parsed
-	// parameter function, it holds
-	// the parameter's name
-	// and the function which will build
-	// the evaluator func.
-	ParamFunc struct {
-		Name string
-		Func ParamEvaluatorBuilder
-	}
-)
-
-func newMacro(evaluator EvaluatorFunc) *Macro {
-	return &Macro{Evaluator: evaluator}
-}
-
-// RegisterFunc registers a parameter function
-// to that macro.
-// Accepts the func name ("range")
-// and the function body, which should return an EvaluatorFunc
-// a bool (it will be converted to EvaluatorFunc later on),
-// i.e RegisterFunc("min", func(minValue int) func(paramValue string) bool){})
-func (m *Macro) RegisterFunc(funcName string, fn interface{}) {
-	fullFn := convertBuilderFunc(fn)
-	m.registerFunc(funcName, fullFn)
-}
-
-func (m *Macro) registerFunc(funcName string, fullFn ParamEvaluatorBuilder) {
-	if !goodParamFuncName(funcName) {
-		return
-	}
-
-	for _, fn := range m.funcs {
-		if fn.Name == funcName {
-			fn.Func = fullFn
-			return
-		}
-	}
-
-	m.funcs = append(m.funcs, ParamFunc{
-		Name: funcName,
-		Func: fullFn,
-	})
-}
-
-func (m *Macro) getFunc(funcName string) ParamEvaluatorBuilder {
-	for _, fn := range m.funcs {
-		if fn.Name == funcName {
-			if fn.Func == nil {
-				continue
-			}
-			return fn.Func
-		}
-	}
-	return nil
-}
-
-// Map contains the default macros mapped to their types.
-// This is the manager which is used by the caller to register custom
-// parameter functions per param-type (String, Int, Long, Boolean, Alphabetical, File, Path).
-type Map struct {
-	// string type
-	// anything
-	String *Macro
-	// uint type
-	// only positive numbers (+0-9)
-	// it could be uint/uint32 but we keep int for simplicity
-	Int *Macro
-	// long an int64 type
-	// only positive numbers (+0-9)
-	// it could be uint64 but we keep int64 for simplicity
-	Long *Macro
-	// boolean as bool type
-	// a string which is "1" or "t" or "T" or "TRUE" or "true" or "True"
-	// or "0" or "f" or "F" or "FALSE" or "false" or "False".
-	Boolean *Macro
-	// alphabetical/letter type
-	// letters only (upper or lowercase)
-	Alphabetical *Macro
-	// file type
-	// letters (upper or lowercase)
-	// numbers (0-9)
-	// underscore (_)
-	// dash (-)
-	// point (.)
-	// no spaces! or other character
-	File *Macro
-	// path type
-	// anything, should be the last part
-	Path *Macro
-}
-
-// NewMap returns a new macro Map with default
-// type evaluators.
-//
-// Learn more at:  https://github.com/kataras/iris/tree/master/_examples/routing/dynamic-path
-func NewMap() *Map {
-	return &Map{
-		// it allows everything, so no need for a regexp here.
-		String: newMacro(func(string) bool { return true }),
-		Int:    newMacro(MustNewEvaluatorFromRegexp("^[0-9]+$")),
-		Long:   newMacro(MustNewEvaluatorFromRegexp("^[0-9]+$")),
-		Boolean: newMacro(func(paramValue string) bool {
-			// a simple if statement is faster than regex ^(true|false|True|False|t|0|f|FALSE|TRUE)$
-			// in this case.
-			_, err := strconv.ParseBool(paramValue)
-			return err == nil
-		}),
-		Alphabetical: newMacro(MustNewEvaluatorFromRegexp("^[a-zA-Z ]+$")),
-		File:         newMacro(MustNewEvaluatorFromRegexp("^[a-zA-Z0-9_.-]*$")),
-		// it allows everything, we have String and Path as different
-		// types because I want to give the opportunity to the user
-		// to organise the macro functions based on wildcard or single dynamic named path parameter.
-		// Should be the last.
-		Path: newMacro(func(string) bool { return true }),
-	}
-}
-
-// Lookup returns the specific Macro from the map
-// based on the parameter type.
-// i.e if ast.ParamTypeInt then it will return the m.Int.
-// Returns the m.String if not matched.
-func (m *Map) Lookup(typ ast.ParamType) *Macro {
-	switch typ {
-	case ast.ParamTypeInt:
-		return m.Int
-	case ast.ParamTypeLong:
-		return m.Long
-	case ast.ParamTypeBoolean:
-		return m.Boolean
-	case ast.ParamTypeAlphabetical:
-		return m.Alphabetical
-	case ast.ParamTypeFile:
-		return m.File
-	case ast.ParamTypePath:
-		return m.Path
-	default:
-		return m.String
-	}
-}

core/router/macro/macro_test.go

@@ -1,186 +0,0 @@
-package macro
-
-import (
-	"reflect"
-	"testing"
-)
-
-// Most important tests to look:
-// ../parser/parser_test.go
-// ../lexer/lexer_test.go
-
-func TestGoodParamFunc(t *testing.T) {
-	good1 := func(min int, max int) func(string) bool {
-		return func(paramValue string) bool {
-			return true
-		}
-	}
-
-	good2 := func(min int, max int) func(string) bool {
-		return func(paramValue string) bool {
-			return true
-		}
-	}
-
-	notgood1 := func(min int, max int) bool {
-		return false
-	}
-
-	if !goodParamFunc(reflect.TypeOf(good1)) {
-		t.Fatalf("expected good1 func to be good but it's not")
-	}
-
-	if !goodParamFunc(reflect.TypeOf(good2)) {
-		t.Fatalf("expected good2 func to be good but it's not")
-	}
-
-	if goodParamFunc(reflect.TypeOf(notgood1)) {
-		t.Fatalf("expected notgood1 func to be the worst")
-	}
-}
-
-func TestGoodParamFuncName(t *testing.T) {
-	tests := []struct {
-		name string
-		good bool
-	}{
-		{"range", true},
-		{"_range", true},
-		{"range_", true},
-		{"r_ange", true},
-		// numbers or other symbols are invalid.
-		{"range1", false},
-		{"2range", false},
-		{"r@nge", false},
-		{"rang3", false},
-	}
-	for i, tt := range tests {
-		isGood := goodParamFuncName(tt.name)
-		if tt.good && !isGood {
-			t.Fatalf("tests[%d] - expecting valid name but got invalid for name %s", i, tt.name)
-		} else if !tt.good && isGood {
-			t.Fatalf("tests[%d] - expecting invalid name but got valid for name %s", i, tt.name)
-		}
-	}
-}
-
-func testEvaluatorRaw(macroEvaluator *Macro, input string, pass bool, i int, t *testing.T) {
-	if got := macroEvaluator.Evaluator(input); pass != got {
-		t.Fatalf("tests[%d] - expecting %v but got %v", i, pass, got)
-	}
-}
-
-func TestStringEvaluatorRaw(t *testing.T) {
-	f := NewMap()
-
-	tests := []struct {
-		pass  bool
-		input string
-	}{
-		{true, "astring"},                         // 0
-		{true, "astringwith_numb3rS_and_symbol$"}, // 1
-		{true, "32321"},                           // 2
-		{true, "main.css"},                        // 3
-		{true, "/assets/main.css"},                // 4
-		// false never
-	} // 0
-
-	for i, tt := range tests {
-		testEvaluatorRaw(f.String, tt.input, tt.pass, i, t)
-	}
-}
-
-func TestIntEvaluatorRaw(t *testing.T) {
-	f := NewMap()
-
-	tests := []struct {
-		pass  bool
-		input string
-	}{
-		{false, "astring"},                         // 0
-		{false, "astringwith_numb3rS_and_symbol$"}, // 1
-		{true, "32321"},                            // 2
-		{false, "main.css"},                        // 3
-		{false, "/assets/main.css"},                // 4
-	}
-
-	for i, tt := range tests {
-		testEvaluatorRaw(f.Int, tt.input, tt.pass, i, t)
-	}
-}
-
-func TestAlphabeticalEvaluatorRaw(t *testing.T) {
-	f := NewMap()
-
-	tests := []struct {
-		pass  bool
-		input string
-	}{
-		{true, "astring"},                          // 0
-		{false, "astringwith_numb3rS_and_symbol$"}, // 1
-		{false, "32321"},                           // 2
-		{false, "main.css"},                        // 3
-		{false, "/assets/main.css"},                // 4
-	}
-
-	for i, tt := range tests {
-		testEvaluatorRaw(f.Alphabetical, tt.input, tt.pass, i, t)
-	}
-}
-
-func TestFileEvaluatorRaw(t *testing.T) {
-	f := NewMap()
-
-	tests := []struct {
-		pass  bool
-		input string
-	}{
-		{true, "astring"},                          // 0
-		{false, "astringwith_numb3rS_and_symbol$"}, // 1
-		{true, "32321"},                            // 2
-		{true, "main.css"},                         // 3
-		{false, "/assets/main.css"},                // 4
-	}
-
-	for i, tt := range tests {
-		testEvaluatorRaw(f.File, tt.input, tt.pass, i, t)
-	}
-}
-
-func TestPathEvaluatorRaw(t *testing.T) {
-	f := NewMap()
-
-	pathTests := []struct {
-		pass  bool
-		input string
-	}{
-		{true, "astring"},                         // 0
-		{true, "astringwith_numb3rS_and_symbol$"}, // 1
-		{true, "32321"},                           // 2
-		{true, "main.css"},                        // 3
-		{true, "/assets/main.css"},                // 4
-		{true, "disk/assets/main.css"},            // 5
-	}
-
-	for i, tt := range pathTests {
-		testEvaluatorRaw(f.Path, tt.input, tt.pass, i, t)
-	}
-}
-
-// func TestMapRegisterFunc(t *testing.T) {
-// 	m := NewMap()
-// 	m.String.RegisterFunc("prefix", func(prefix string) EvaluatorFunc {
-// 		return func(paramValue string) bool {
-// 			return strings.HasPrefix(paramValue, prefix)
-// 		}
-// 	})
-
-// 	p, err := Parse("/user/@iris")
-// 	if err != nil {
-// 		t.Fatalf(err)
-// 	}
-
-// 	// 	p.Params = append(p.)
-
-// 	testEvaluatorRaw(m.String, p.Src, false, 0, t)
-// }

core/router/macro/template.go

@@ -1,75 +0,0 @@
-package macro
-
-import (
-	"github.com/kataras/iris/core/router/macro/interpreter/ast"
-	"github.com/kataras/iris/core/router/macro/interpreter/parser"
-)
-
-// Template contains a route's path full parsed template.
-//
-// Fields:
-// Src is the raw source of the path, i.e /users/{id:int min(1)}
-// Params is the list of the Params that are being used to the
-// path,  i.e the min as param name and  1 as the param argument.
-type Template struct {
-	// Src is the original template given by the client
-	Src    string          `json:"src"`
-	Params []TemplateParam `json:"params"`
-}
-
-// TemplateParam is the parsed macro parameter's template
-// they are being used to describe the param's syntax result.
-type TemplateParam struct {
-	Src string `json:"src"` // the unparsed param'false source
-	// Type is not useful anywhere here but maybe
-	// it's useful on host to decide how to convert the path template to specific router's syntax
-	Type          ast.ParamType   `json:"type"`
-	Name          string          `json:"name"`
-	ErrCode       int             `json:"errCode"`
-	TypeEvaluator EvaluatorFunc   `json:"-"`
-	Funcs         []EvaluatorFunc `json:"-"`
-}
-
-// Parse takes a full route path and a macro map (macro map contains the macro types with their registered param functions)
-// and returns a new Template.
-// It builds all the parameter functions for that template
-// and their evaluators, it's the api call that makes use the interpeter's parser -> lexer.
-func Parse(src string, macros *Map) (*Template, error) {
-	params, err := parser.Parse(src)
-	if err != nil {
-		return nil, err
-	}
-	t := new(Template)
-	t.Src = src
-
-	for _, p := range params {
-		funcMap := macros.Lookup(p.Type)
-		typEval := funcMap.Evaluator
-
-		tmplParam := TemplateParam{
-			Src:           p.Src,
-			Type:          p.Type,
-			Name:          p.Name,
-			ErrCode:       p.ErrorCode,
-			TypeEvaluator: typEval,
-		}
-		for _, paramfn := range p.Funcs {
-			tmplFn := funcMap.getFunc(paramfn.Name)
-			if tmplFn == nil { // if not find on this type, check for String's which is for global funcs too
-				tmplFn = macros.String.getFunc(paramfn.Name)
-				if tmplFn == nil { // if not found then just skip this param
-					continue
-				}
-			}
-			evalFn := tmplFn(paramfn.Args)
-			if evalFn == nil {
-				continue
-			}
-			tmplParam.Funcs = append(tmplParam.Funcs, evalFn)
-		}
-
-		t.Params = append(t.Params, tmplParam)
-	}
-
-	return t, nil
-}

core/router/node/node.go

@@ -1,448 +0,0 @@
-package node
-
-import (
-	"sort"
-	"strings"
-
-	"github.com/kataras/iris/context"
-	"github.com/kataras/iris/core/errors"
-)
-
-// Nodes a conversion type for []*node.
-type Nodes []*node
-
-type node struct {
-	s                 string
-	routeName         string
-	wildcardParamName string   // name of the wildcard parameter, only one per whole Node is allowed
-	paramNames        []string // only-names
-	childrenNodes     Nodes
-	handlers          context.Handlers
-	root              bool
-	rootWildcard      bool // if it's a wildcard {path} type on root, it should allow everything but it is not conflicts with
-	// any other static or dynamic or wildcard paths if exists on other nodes.
-}
-
-// ErrDublicate returnned from `Add` when two or more routes have the same registered path.
-var ErrDublicate = errors.New("two or more routes have the same registered path")
-
-/// TODO: clean up needed until v8.5
-
-// Add adds a node to the tree, returns an ErrDublicate error on failure.
-func (nodes *Nodes) Add(routeName string, path string, handlers context.Handlers) error {
-	// println("[Add] adding path: " + path)
-	// resolve params and if that node should be added as root
-	var params []string
-	var paramStart, paramEnd int
-	for {
-		paramStart = strings.IndexByte(path[paramEnd:], ':')
-		if paramStart == -1 {
-			break
-		}
-		paramStart += paramEnd
-		paramStart++
-		paramEnd = strings.IndexByte(path[paramStart:], '/')
-
-		if paramEnd == -1 {
-			params = append(params, path[paramStart:])
-			path = path[:paramStart]
-			break
-		}
-		paramEnd += paramStart
-		params = append(params, path[paramStart:paramEnd])
-		path = path[:paramStart] + path[paramEnd:]
-		paramEnd -= paramEnd - paramStart
-	}
-
-	var p []int
-	for i := 0; i < len(path); i++ {
-		idx := strings.IndexByte(path[i:], ':')
-		if idx == -1 {
-			break
-		}
-		p = append(p, idx+i)
-		i = idx + i
-	}
-
-	for _, idx := range p {
-		// print("-2 nodes.Add: path: " + path + " params len: ")
-		// println(len(params))
-		if err := nodes.add(routeName, path[:idx], nil, nil, true); err != nil {
-			return err
-		}
-		// print("-1 nodes.Add: path: " + path + " params len: ")
-		// println(len(params))
-		if nidx := idx + 1; len(path) > nidx {
-			if err := nodes.add(routeName, path[:nidx], nil, nil, true); err != nil {
-				return err
-			}
-		}
-	}
-
-	// print("nodes.Add: path: " + path + " params len: ")
-	// println(len(params))
-	if err := nodes.add(routeName, path, params, handlers, true); err != nil {
-		return err
-	}
-
-	// prioritize by static path remember, they were already sorted by subdomains too.
-	nodes.prioritize()
-	return nil
-}
-
-func (nodes *Nodes) add(routeName, path string, paramNames []string, handlers context.Handlers, root bool) (err error) {
-	// println("[add] route name: " + routeName)
-	// println("[add] adding path: " + path)
-
-	// wraia etsi doulevei ara
-	// na to kanw na exei to node to diko tou wildcard parameter name
-	// kai sto telos na pernei auto, me vasi to *paramname
-	// alla edw mesa 9a ginete register vasi tou last /
-
-	// set the wildcard param name to the root and its children.
-	wildcardIdx := strings.IndexByte(path, '*')
-	wildcardParamName := ""
-	if wildcardIdx > 0 && len(paramNames) == 0 { // 27 Oct comment: && len(paramNames) == 0 {
-		wildcardParamName = path[wildcardIdx+1:]
-		path = path[0:wildcardIdx-1] + "/" // replace *paramName with single slash
-
-		// if path[len(path)-1] == '/' {
-		// if root wildcard, then add it as it's and return
-		rootWildcard := path == "/"
-		if rootWildcard {
-			path += "/" // if root wildcard, then do it like "//" instead of simple "/"
-		}
-
-		n := &node{
-			rootWildcard:      rootWildcard,
-			s:                 path,
-			routeName:         routeName,
-			wildcardParamName: wildcardParamName,
-			paramNames:        paramNames,
-			handlers:          handlers,
-			root:              root,
-		}
-		*nodes = append(*nodes, n)
-		// println("1. nodes.Add path: " + path)
-		return
-
-	}
-
-loop:
-	for _, n := range *nodes {
-		if n.rootWildcard {
-			continue
-		}
-
-		if len(n.paramNames) == 0 && n.wildcardParamName != "" {
-			continue
-		}
-
-		minlen := len(n.s)
-		if len(path) < minlen {
-			minlen = len(path)
-		}
-
-		for i := 0; i < minlen; i++ {
-			if n.s[i] == path[i] {
-				continue
-			}
-			if i == 0 {
-				continue loop
-			}
-
-			*n = node{
-				s: n.s[:i],
-				childrenNodes: Nodes{
-					{
-						s:                 n.s[i:],
-						routeName:         n.routeName,
-						wildcardParamName: n.wildcardParamName, // wildcardParamName
-						paramNames:        n.paramNames,
-						childrenNodes:     n.childrenNodes,
-						handlers:          n.handlers,
-					},
-					{
-						s:                 path[i:],
-						routeName:         routeName,
-						wildcardParamName: wildcardParamName,
-						paramNames:        paramNames,
-						handlers:          handlers,
-					},
-				},
-				root: n.root,
-			}
-
-			// println("2. change n and return  " + n.s[:i] + " and " + path[i:])
-			return
-		}
-
-		if len(path) < len(n.s) {
-			// 	println("3. change n and return | n.s[:len(path)] = " + n.s[:len(path)-1] + " and child: " + n.s[len(path)-1:])
-
-			*n = node{
-				s:                 n.s[:len(path)],
-				routeName:         routeName,
-				wildcardParamName: wildcardParamName,
-				paramNames:        paramNames,
-				childrenNodes: Nodes{
-					{
-						s:                 n.s[len(path):],
-						routeName:         n.routeName,
-						wildcardParamName: n.wildcardParamName, // wildcardParamName
-						paramNames:        n.paramNames,
-						childrenNodes:     n.childrenNodes,
-						handlers:          n.handlers,
-					},
-				},
-				handlers: handlers,
-				root:     n.root,
-			}
-
-			return
-		}
-
-		if len(path) > len(n.s) {
-			if n.wildcardParamName != "" {
-				n := &node{
-					s:                 path,
-					routeName:         routeName,
-					wildcardParamName: wildcardParamName,
-					paramNames:        paramNames,
-					handlers:          handlers,
-					root:              root,
-				}
-				// println("3.5. nodes.Add path: " + n.s)
-				*nodes = append(*nodes, n)
-				return
-			}
-
-			pathToAdd := path[len(n.s):]
-			// println("4. nodes.Add route name: " + routeName)
-			// println("4. nodes.Add path: " + pathToAdd)
-			err = n.childrenNodes.add(routeName, pathToAdd, paramNames, handlers, false)
-			return err
-		}
-
-		if len(handlers) == 0 { // missing handlers
-			return nil
-		}
-
-		if len(n.handlers) > 0 { // n.handlers already setted
-			return ErrDublicate
-		}
-		n.paramNames = paramNames
-		n.handlers = handlers
-		n.routeName = routeName
-		return
-	}
-
-	// START
-	// Author's note:
-	// 27 Oct 2017; fixes s|i|l+static+p
-	//			    without breaking the current tests.
-	if wildcardIdx > 0 {
-		wildcardParamName = path[wildcardIdx+1:]
-		path = path[0:wildcardIdx-1] + "/"
-	}
-	// END
-
-	n := &node{
-		s:                 path,
-		routeName:         routeName,
-		wildcardParamName: wildcardParamName,
-		paramNames:        paramNames,
-		handlers:          handlers,
-		root:              root,
-	}
-	*nodes = append(*nodes, n)
-
-	// println("5. node add on path: " + path + " n.s: " + n.s + " wildcard param: " + n.wildcardParamName)
-	return
-}
-
-// Find resolves the path, fills its params
-// and returns the registered to the resolved node's handlers.
-func (nodes Nodes) Find(path string, params *context.RequestParams) (string, context.Handlers) {
-	n, paramValues := nodes.findChild(path, nil)
-	if n != nil {
-		//	map the params,
-		// n.params are the param names
-		if len(paramValues) > 0 {
-			// println("-----------")
-			// print("param values returned len: ")
-			// println(len(paramValues))
-			// println("first value is: " + paramValues[0])
-			// print("n.paramNames len: ")
-			// println(len(n.paramNames))
-			for i, name := range n.paramNames {
-				// println("setting param name: " + name + " = " + paramValues[i])
-				params.Set(name, paramValues[i])
-			}
-			// last is the wildcard,
-			// if paramValues are exceed from the registered param names.
-			// Note that n.wildcardParamName can be not empty but that doesn't meaning
-			// that it contains a wildcard path, so the check is required.
-			if len(paramValues) > len(n.paramNames) {
-				// println("len(paramValues) > len(n.paramNames)")
-				lastWildcardVal := paramValues[len(paramValues)-1]
-				// println("setting wildcard param name: " + n.wildcardParamName + " = " + lastWildcardVal)
-				params.Set(n.wildcardParamName, lastWildcardVal)
-			}
-		}
-
-		return n.routeName, n.handlers
-	}
-
-	return "", nil
-}
-
-// Exists returns true if a node with that "path" exists,
-// otherise false.
-//
-// We don't care about parameters here.
-func (nodes Nodes) Exists(path string) bool {
-	n, _ := nodes.findChild(path, nil)
-	return n != nil && len(n.handlers) > 0
-}
-
-func (nodes Nodes) findChild(path string, params []string) (*node, []string) {
-
-	for _, n := range nodes {
-		if n.s == ":" {
-			paramEnd := strings.IndexByte(path, '/')
-			if paramEnd == -1 {
-				if len(n.handlers) == 0 {
-					return nil, nil
-				}
-				return n, append(params, path)
-			}
-			return n.childrenNodes.findChild(path[paramEnd:], append(params, path[:paramEnd]))
-		}
-
-		// println("n.s: " + n.s)
-		// print("n.childrenNodes len: ")
-		// println(len(n.childrenNodes))
-		// print("n.root: ")
-		// println(n.root)
-
-		// by runtime check of:,
-		// if n.s == "//" && n.root && n.wildcardParamName != "" {
-		// but this will slow down, so we have a static field on the node itself:
-		if n.rootWildcard {
-			// println("return from n.rootWildcard")
-			// single root wildcard
-			if len(path) < 2 {
-				// do not remove that, it seems useless but it's not,
-				// we had an error while production, this fixes that.
-				path = "/" + path
-			}
-			return n, append(params, path[1:])
-		}
-
-		// second conditional may be unnecessary
-		// because of the n.rootWildcard before, but do it.
-		if n.wildcardParamName != "" && len(path) > 2 {
-			// println("n has wildcard n.s: " + n.s + " on path: " + path)
-			// n.s = static/, path = static
-
-			// 	println(n.s + " vs path: " + path)
-
-			// we could have /other/ as n.s so
-			// we must do this check, remember:
-			// now wildcards live on their own nodes
-			if len(path) == len(n.s)-1 {
-				// then it's like:
-				// path = /other2
-				// ns = /other2/
-				if path == n.s[0:len(n.s)-1] {
-					return n, params
-				}
-			}
-
-			// othwerwise path = /other2/dsadas
-			// ns= /other2/
-			if strings.HasPrefix(path, n.s) {
-				if len(path) > len(n.s)+1 {
-					return n, append(params, path[len(n.s):]) // without slash
-				}
-			}
-
-		}
-
-		if !strings.HasPrefix(path, n.s) {
-			// fmt.Printf("---here root: %v, n.s: "+n.s+" and path: "+path+" is dynamic: %v , wildcardParamName: %s, children len: %v \n", n.root, n.isDynamic(), n.wildcardParamName, len(n.childrenNodes))
-			// println(path + " n.s: " + n.s + " continue...")
-			continue
-		}
-
-		if len(path) == len(n.s) {
-			if len(n.handlers) == 0 {
-				return nil, nil
-			}
-			return n, params
-		}
-
-		child, childParamNames := n.childrenNodes.findChild(path[len(n.s):], params)
-
-		// print("childParamNames len: ")
-		// println(len(childParamNames))
-
-		// if len(childParamNames) > 0 {
-		// 	println("childParamsNames[0] = " + childParamNames[0])
-		// }
-
-		if child == nil || len(child.handlers) == 0 {
-			if n.s[len(n.s)-1] == '/' && !(n.root && (n.s == "/" || len(n.childrenNodes) > 0)) {
-				if len(n.handlers) == 0 {
-					return nil, nil
-				}
-
-				// println("if child == nil.... | n.s = " + n.s)
-				// print("n.paramNames len: ")
-				// println(n.paramNames)
-				// print("n.wildcardParamName is: ")
-				// println(n.wildcardParamName)
-				// print("return n, append(params, path[len(n.s) | params: ")
-				// println(path[len(n.s):])
-				return n, append(params, path[len(n.s):])
-			}
-
-			continue
-		}
-
-		return child, childParamNames
-	}
-	return nil, nil
-}
-
-// childLen returns all the children's and their children's length.
-func (n *node) childLen() (i int) {
-	for _, n := range n.childrenNodes {
-		i++
-		i += n.childLen()
-	}
-	return
-}
-
-func (n *node) isDynamic() bool {
-	return n.s == ":" || n.wildcardParamName != "" || n.rootWildcard
-}
-
-// prioritize sets the static paths first.
-func (nodes Nodes) prioritize() {
-	sort.Slice(nodes, func(i, j int) bool {
-		if nodes[i].isDynamic() {
-			return false
-		}
-		if nodes[j].isDynamic() {
-			return true
-		}
-
-		return nodes[i].childLen() > nodes[j].childLen()
-	})
-
-	for _, n := range nodes {
-		n.childrenNodes.prioritize()
-	}
-}

core/router/party.go

@@ -3,7 +3,7 @@ package router
 import (
 	"github.com/kataras/iris/context"
 	"github.com/kataras/iris/core/errors"
-	"github.com/kataras/iris/core/router/macro"
+	"github.com/kataras/iris/macro"
 )
 
 // Party is just a group joiner of routes which have the same prefix and share same middleware(s) also.
@@ -18,11 +18,11 @@ type Party interface {
 	GetRelPath() string
 	// GetReporter returns the reporter for adding errors
 	GetReporter() *errors.Reporter
-	// Macros returns the macro map which is responsible
-	// to register custom macro functions for all routes.
+	// Macros returns the macro collection that is responsible
+	// to register custom macros with their own parameter types and their macro functions for all routes.
 	//
 	// Learn more at:  https://github.com/kataras/iris/tree/master/_examples/routing/dynamic-path
-	Macros() *macro.Map
+	Macros() *macro.Macros
 
 	// Party groups routes which may have the same prefix and share same handlers,
 	// returns that new rich subrouter.
@@ -110,10 +110,10 @@ type Party interface {
 	// otherwise use `Party` which can handle many paths with different handlers and middlewares.
 	//
 	// Usage:
-	// 	app.HandleMany(iris.MethodGet, "/user /user/{id:int} /user/me", userHandler)
+	// 	app.HandleMany(iris.MethodGet, "/user /user/{id:uint64} /user/me", userHandler)
 	// At the other side, with `Handle` we've had to write:
 	// 	app.Handle(iris.MethodGet, "/user", userHandler)
-	// 	app.Handle(iris.MethodGet, "/user/{id:int}", userHandler)
+	// 	app.Handle(iris.MethodGet, "/user/{id:uint64}", userHandler)
 	// 	app.Handle(iris.MethodGet, "/user/me", userHandler)
 	//
 	// This method is used behind the scenes at the `Controller` function

core/router/path.go

@@ -7,15 +7,9 @@ import (
 	"strings"
 
 	"github.com/kataras/iris/core/netutil"
-	"github.com/kataras/iris/core/router/macro/interpreter/lexer"
-)
-
-const (
-	// ParamStart the character in string representation where the underline router starts its dynamic named parameter.
-	ParamStart = ":"
-	// WildcardParamStart the character in string representation where the underline router starts its dynamic wildcard
-	// path parameter.
-	WildcardParamStart = "*"
+	"github.com/kataras/iris/macro"
+	"github.com/kataras/iris/macro/interpreter/ast"
+	"github.com/kataras/iris/macro/interpreter/lexer"
 )
 
 // Param receives a parameter name prefixed with the ParamStart symbol.
@@ -31,6 +25,26 @@ func WildcardParam(name string) string {
 	return prefix(name, WildcardParamStart)
 }
 
+func convertMacroTmplToNodePath(tmpl macro.Template) string {
+	routePath := tmpl.Src
+	if len(routePath) > 1 && routePath[len(routePath)-1] == '/' {
+		routePath = routePath[0 : len(routePath)-1] // remove any last "/"
+	}
+
+	// if it has started with {} and it's valid
+	// then the tmpl.Params will be filled,
+	// so no any further check needed.
+	for _, p := range tmpl.Params {
+		if ast.IsTrailing(p.Type) {
+			routePath = strings.Replace(routePath, p.Src, WildcardParam(p.Name), 1)
+		} else {
+			routePath = strings.Replace(routePath, p.Src, Param(p.Name), 1)
+		}
+	}
+
+	return routePath
+}
+
 func prefix(s string, prefix string) string {
 	if !strings.HasPrefix(s, prefix) {
 		return prefix + s

core/router/path_test.go

@@ -27,8 +27,8 @@ func TestCleanPath(t *testing.T) {
 			"/total/{year:string regexp(\\d{4})}/more/{s:string regexp(\\d{7})}"},
 		{"/single_no_params",
 			"/single_no_params"},
-		{"/single/{id:int}",
-			"/single/{id:int}"},
+		{"/single/{id:uint64}",
+			"/single/{id:uint64}"},
 	}
 
 	for i, tt := range tests {
@@ -45,8 +45,10 @@ func TestSplitPath(t *testing.T) {
 	}{
 		{"/v2/stores/{id:string format(uuid)} /v3",
 			[]string{"/v2/stores/{id:string format(uuid)}", "/v3"}},
-		{"/user/{id:int} /admin/{id:int}",
-			[]string{"/user/{id:int}", "/admin/{id:int}"}},
+		{"/user/{id:uint64} /admin/{id:uint64}",
+			[]string{"/user/{id:uint64}", "/admin/{id:uint64}"}},
+		{"/users/{id:int} /admins/{id:int64}",
+			[]string{"/users/{id:int}", "/admins/{id:int64}"}},
 		{"/user /admin",
 			[]string{"/user", "/admin"}},
 		{"/single_no_params",

core/router/route.go

@@ -5,18 +5,19 @@ import (
 	"strings"
 
 	"github.com/kataras/iris/context"
-	"github.com/kataras/iris/core/router/macro"
+	"github.com/kataras/iris/macro"
+	"github.com/kataras/iris/macro/handler"
 )
 
 // Route contains the information about a registered Route.
 // If any of the following fields are changed then the
 // caller should Refresh the router.
 type Route struct {
-	Name       string          `json:"name"`   // "userRoute"
-	Method     string          `json:"method"` // "GET"
-	methodBckp string          // if Method changed to something else (which is possible at runtime as well, via RefreshRouter) then this field will be filled with the old one.
-	Subdomain  string          `json:"subdomain"` // "admin."
-	tmpl       *macro.Template // Tmpl().Src: "/api/user/{id:int}"
+	Name       string         `json:"name"`   // "userRoute"
+	Method     string         `json:"method"` // "GET"
+	methodBckp string         // if Method changed to something else (which is possible at runtime as well, via RefreshRouter) then this field will be filled with the old one.
+	Subdomain  string         `json:"subdomain"` // "admin."
+	tmpl       macro.Template // Tmpl().Src: "/api/user/{id:uint64}"
 	// temp storage, they're appended to the Handlers on build.
 	// Execution happens before Handlers, can be empty.
 	beginHandlers context.Handlers
@@ -39,16 +40,19 @@ type Route struct {
 // It parses the path based on the "macros",
 // handlers are being changed to validate the macros at serve time, if needed.
 func NewRoute(method, subdomain, unparsedPath, mainHandlerName string,
-	handlers context.Handlers, macros *macro.Map) (*Route, error) {
+	handlers context.Handlers, macros macro.Macros) (*Route, error) {
 
 	tmpl, err := macro.Parse(unparsedPath, macros)
 	if err != nil {
 		return nil, err
 	}
 
-	path, handlers, err := compileRoutePathAndHandlers(handlers, tmpl)
-	if err != nil {
-		return nil, err
+	path := convertMacroTmplToNodePath(tmpl)
+	// prepend the macro handler to the route, now,
+	// right before the register to the tree, so APIBuilder#UseGlobal will work as expected.
+	if handler.CanMakeHandler(tmpl) {
+		macroEvaluatorHandler := handler.MakeHandler(tmpl)
+		handlers = append(context.Handlers{macroEvaluatorHandler}, handlers...)
 	}
 
 	path = cleanPath(path) // maybe unnecessary here but who cares in this moment
@@ -152,7 +156,18 @@ func (r Route) String() string {
 // via Tmpl().Src, Route.Path is the path
 // converted to match the underline router's specs.
 func (r Route) Tmpl() macro.Template {
-	return *r.tmpl
+	return r.tmpl
+}
+
+// RegisteredHandlersLen returns the end-developer's registered handlers, all except the macro evaluator handler
+// if was required by the build process.
+func (r Route) RegisteredHandlersLen() int {
+	n := len(r.Handlers)
+	if handler.CanMakeHandler(r.tmpl) {
+		n--
+	}
+
+	return n
 }
 
 // IsOnline returns true if the route is marked as "online" (state).
@@ -198,7 +213,7 @@ func formatPath(path string) string {
 
 // StaticPath returns the static part of the original, registered route path.
 // if /user/{id} it will return /user
-// if /user/{id}/friend/{friendid:int} it will return /user too
+// if /user/{id}/friend/{friendid:uint64} it will return /user too
 // if /assets/{filepath:path} it will return /assets.
 func (r Route) StaticPath() string {
 	src := r.tmpl.Src
@@ -242,7 +257,8 @@ func (r Route) Trace() string {
 		printfmt += fmt.Sprintf(" %s", r.Subdomain)
 	}
 	printfmt += fmt.Sprintf(" %s ", r.Tmpl().Src)
-	if l := len(r.Handlers); l > 1 {
+
+	if l := r.RegisteredHandlersLen(); l > 1 {
 		printfmt += fmt.Sprintf("-> %s() and %d more", r.MainHandlerName, l-1)
 	} else {
 		printfmt += fmt.Sprintf("-> %s()", r.MainHandlerName)

core/router/router.go

@@ -31,7 +31,7 @@ func NewRouter() *Router { return &Router{} }
 // RefreshRouter re-builds the router. Should be called when a route's state
 // changed (i.e Method changed at serve-time).
 func (router *Router) RefreshRouter() error {
-	return router.BuildRouter(router.cPool, router.requestHandler, router.routesProvider)
+	return router.BuildRouter(router.cPool, router.requestHandler, router.routesProvider, true)
 }
 
 // BuildRouter builds the router based on
@@ -41,7 +41,7 @@ func (router *Router) RefreshRouter() error {
 // its wrapper.
 //
 // Use of RefreshRouter to re-build the router if needed.
-func (router *Router) BuildRouter(cPool *context.Pool, requestHandler RequestHandler, routesProvider RoutesProvider) error {
+func (router *Router) BuildRouter(cPool *context.Pool, requestHandler RequestHandler, routesProvider RoutesProvider, force bool) error {
 
 	if requestHandler == nil {
 		return errors.New("router: request handler is nil")
@@ -60,9 +60,23 @@ func (router *Router) BuildRouter(cPool *context.Pool, requestHandler RequestHan
 	defer router.mu.Unlock()
 
 	// store these for RefreshRouter's needs.
-	router.cPool = cPool
-	router.requestHandler = requestHandler
-	router.routesProvider = routesProvider
+	if force {
+		router.cPool = cPool
+		router.requestHandler = requestHandler
+		router.routesProvider = routesProvider
+	} else {
+		if router.cPool == nil {
+			router.cPool = cPool
+		}
+
+		if router.requestHandler == nil {
+			router.requestHandler = requestHandler
+		}
+
+		if router.routesProvider == nil && routesProvider != nil {
+			router.routesProvider = routesProvider
+		}
+	}
 
 	// the important
 	router.mainHandler = func(w http.ResponseWriter, r *http.Request) {

core/router/router_wildcard_root_test.go

@@ -122,20 +122,25 @@ func TestRouterWildcardRootMany(t *testing.T) {
 
 func TestRouterWildcardRootManyAndRootStatic(t *testing.T) {
 	var tt = []testRoute{
-		// all routes will be handlded by "h" because we added wildcard to root,
+		// routes that may return 404 will be handled by the below route ("h" handler) because we added wildcard to root,
 		// this feature is very important and can remove noumerous of previous hacks on our apps.
+		//
+		// Static paths and parameters have priority over wildcard, all three types can be registered in the same path prefix.
+		//
+		// Remember, all of those routes are registered don't be tricked by the visual appearance of the below test blocks.
 		{"GET", "/{p:path}", h, []testRouteRequest{
 			{"GET", "", "/other2almost/some", iris.StatusOK, same_as_request_path},
 		}},
 		{"GET", "/static/{p:path}", h, []testRouteRequest{
-			{"GET", "", "/static", iris.StatusOK, same_as_request_path},
+			{"GET", "", "/static", iris.StatusOK, same_as_request_path}, // HERE<- IF NOT FOUND THEN BACKWARDS TO WILDCARD IF THERE IS ONE, HMM.
 			{"GET", "", "/static/something/here", iris.StatusOK, same_as_request_path},
 		}},
 		{"GET", "/", h, []testRouteRequest{
 			{"GET", "", "/", iris.StatusOK, same_as_request_path},
 		}},
 		{"GET", "/other/{paramother:path}", h2, []testRouteRequest{
-			{"GET", "", "/other", iris.StatusForbidden, same_as_request_path},
+			// OK and not h2 because of the root wildcard.
+			{"GET", "", "/other", iris.StatusOK, same_as_request_path},
 			{"GET", "", "/other/wildcard", iris.StatusForbidden, same_as_request_path},
 			{"GET", "", "/other/wildcard/here", iris.StatusForbidden, same_as_request_path},
 		}},
@@ -145,6 +150,7 @@ func TestRouterWildcardRootManyAndRootStatic(t *testing.T) {
 		}},
 		{"GET", "/other2/static", h3, []testRouteRequest{
 			{"GET", "", "/other2/static", iris.StatusOK, prefix_static_path_following_by_request_path},
+			// h2(Forbiddenn) instead of h3 OK because it will be handled by the /other2/{paramothersecond:path}'s handler which gives 403.
 			{"GET", "", "/other2/staticed", iris.StatusForbidden, same_as_request_path},
 		}},
 	}
@@ -165,6 +171,7 @@ func testTheRoutes(t *testing.T, tests []testRoute, debug bool) {
 	// run the tests
 	for _, tt := range tests {
 		for _, req := range tt.requests {
+			// t.Logf("req: %s:%s\n", tt.method, tt.path)
 			method := req.method
 			if method == "" {
 				method = tt.method

core/router/trie.go

@@ -0,0 +1,268 @@
+package router
+
+import (
+	"strings"
+
+	"github.com/kataras/iris/context"
+)
+
+const (
+	// ParamStart the character in string representation where the underline router starts its dynamic named parameter.
+	ParamStart = ":"
+	// WildcardParamStart the character in string representation where the underline router starts its dynamic wildcard
+	// path parameter.
+	WildcardParamStart = "*"
+)
+
+// An iris-specific identical version of the https://github.com/kataras/muxie version 1.0.0 released at 15 Oct 2018
+type trieNode struct {
+	parent *trieNode
+
+	children               map[string]*trieNode
+	hasDynamicChild        bool     // does one of the children contains a parameter or wildcard?
+	childNamedParameter    bool     // is the child a named parameter (single segmnet)
+	childWildcardParameter bool     // or it is a wildcard (can be more than one path segments) ?
+	paramKeys              []string // the param keys without : or *.
+	end                    bool     // it is a complete node, here we stop and we can say that the node is valid.
+	key                    string   // if end == true then key is filled with the original value of the insertion's key.
+	// if key != "" && its parent has childWildcardParameter == true,
+	// we need it to track the static part for the closest-wildcard's parameter storage.
+	staticKey string
+
+	// insert data.
+	Handlers  context.Handlers
+	RouteName string
+}
+
+func newTrieNode() *trieNode {
+	n := new(trieNode)
+	return n
+}
+
+func (tn *trieNode) hasChild(s string) bool {
+	return tn.getChild(s) != nil
+}
+
+func (tn *trieNode) getChild(s string) *trieNode {
+	if tn.children == nil {
+		tn.children = make(map[string]*trieNode)
+	}
+
+	return tn.children[s]
+}
+
+func (tn *trieNode) addChild(s string, n *trieNode) {
+	if tn.children == nil {
+		tn.children = make(map[string]*trieNode)
+	}
+
+	if _, exists := tn.children[s]; exists {
+		return
+	}
+
+	n.parent = tn
+	tn.children[s] = n
+}
+
+func (tn *trieNode) findClosestParentWildcardNode() *trieNode {
+	tn = tn.parent
+	for tn != nil {
+		if tn.childWildcardParameter {
+			return tn.getChild(WildcardParamStart)
+		}
+
+		tn = tn.parent
+	}
+
+	return nil
+}
+
+func (tn *trieNode) String() string {
+	return tn.key
+}
+
+type trie struct {
+	root *trieNode
+
+	// if true then it will handle any path if not other parent wildcard exists,
+	// so even 404 (on http services) is up to it, see trie#insert.
+	hasRootWildcard bool
+
+	method string
+	// subdomain is empty for default-hostname routes,
+	// ex: mysubdomain.
+	subdomain string
+}
+
+func newTrie() *trie {
+	return &trie{
+		root: newTrieNode(),
+	}
+}
+
+const (
+	pathSep  = "/"
+	pathSepB = '/'
+)
+
+func slowPathSplit(path string) []string {
+	if path == "/" {
+		return []string{"/"}
+	}
+
+	return strings.Split(path, pathSep)[1:]
+}
+
+func (tr *trie) insert(path, routeName string, handlers context.Handlers) {
+	input := slowPathSplit(path)
+
+	n := tr.root
+	var paramKeys []string
+
+	for _, s := range input {
+		c := s[0]
+
+		if isParam, isWildcard := c == ParamStart[0], c == WildcardParamStart[0]; isParam || isWildcard {
+			n.hasDynamicChild = true
+			paramKeys = append(paramKeys, s[1:]) // without : or *.
+
+			// if node has already a wildcard, don't force a value, check for true only.
+			if isParam {
+				n.childNamedParameter = true
+				s = ParamStart
+			}
+
+			if isWildcard {
+				n.childWildcardParameter = true
+				s = WildcardParamStart
+				if tr.root == n {
+					tr.hasRootWildcard = true
+				}
+			}
+		}
+
+		if !n.hasChild(s) {
+			child := newTrieNode()
+			n.addChild(s, child)
+		}
+
+		n = n.getChild(s)
+	}
+
+	n.RouteName = routeName
+	n.Handlers = handlers
+	n.paramKeys = paramKeys
+	n.key = path
+	n.end = true
+
+	i := strings.Index(path, ParamStart)
+	if i == -1 {
+		i = strings.Index(path, WildcardParamStart)
+	}
+	if i == -1 {
+		i = len(n.key)
+	}
+
+	n.staticKey = path[:i]
+}
+
+func (tr *trie) search(q string, params *context.RequestParams) *trieNode {
+	end := len(q)
+
+	if end == 0 || (end == 1 && q[0] == pathSepB) {
+		return tr.root.getChild(pathSep)
+	}
+
+	n := tr.root
+	start := 1
+	i := 1
+	var paramValues []string
+
+	for {
+		if i == end || q[i] == pathSepB {
+			if child := n.getChild(q[start:i]); child != nil {
+				n = child
+			} else if n.childNamedParameter {
+				n = n.getChild(ParamStart)
+				if ln := len(paramValues); cap(paramValues) > ln {
+					paramValues = paramValues[:ln+1]
+					paramValues[ln] = q[start:i]
+				} else {
+					paramValues = append(paramValues, q[start:i])
+				}
+			} else if n.childWildcardParameter {
+				n = n.getChild(WildcardParamStart)
+				if ln := len(paramValues); cap(paramValues) > ln {
+					paramValues = paramValues[:ln+1]
+					paramValues[ln] = q[start:]
+				} else {
+					paramValues = append(paramValues, q[start:])
+				}
+				break
+			} else {
+				n = n.findClosestParentWildcardNode()
+				if n != nil {
+					// means that it has :param/static and *wildcard, we go trhough the :param
+					// but the next path segment is not the /static, so go back to *wildcard
+					// instead of not found.
+					//
+					// Fixes:
+					// /hello/*p
+					// /hello/:p1/static/:p2
+					// req: http://localhost:8080/hello/dsadsa/static/dsadsa => found
+					// req: http://localhost:8080/hello/dsadsa => but not found!
+					// and
+					// /second/wild/*p
+					// /second/wild/static/otherstatic/
+					// req: /second/wild/static/otherstatic/random => but not found!
+					params.Set(n.paramKeys[0], q[len(n.staticKey):])
+					return n
+				}
+
+				return nil
+			}
+
+			if i == end {
+				break
+			}
+
+			i++
+			start = i
+			continue
+		}
+
+		i++
+	}
+
+	if n == nil || !n.end {
+		if n != nil { // we need it on both places, on last segment (below) or on the first unnknown (above).
+			if n = n.findClosestParentWildcardNode(); n != nil {
+				params.Set(n.paramKeys[0], q[len(n.staticKey):])
+				return n
+			}
+		}
+
+		if tr.hasRootWildcard {
+			// that's the case for root wildcard, tests are passing
+			// even without it but stick with it for reference.
+			// Note ote that something like:
+			// Routes: /other2/*myparam and /other2/static
+			// Reqs: /other2/staticed will be handled
+			// the /other2/*myparam and not the root wildcard, which is what we want.
+			//
+			n = tr.root.getChild(WildcardParamStart)
+			params.Set(n.paramKeys[0], q[1:])
+			return n
+		}
+
+		return nil
+	}
+
+	for i, paramValue := range paramValues {
+		if len(n.paramKeys) > i {
+			params.Set(n.paramKeys[i], paramValue)
+		}
+	}
+
+	return n
+}

deprecated.go

@@ -1 +0,0 @@
-package iris

doc.go

@@ -35,11 +35,11 @@ Source code and other details for the project are available at GitHub:
 
 Current Version
 
-10.7.0
+11.0.0
 
 Installation
 
-The only requirement is the Go Programming Language, at least version 1.8 but 1.10 and above is highly recommended.
+The only requirement is the Go Programming Language, at least version 1.8 but 1.11.1 and above is highly recommended.
 
     $ go get -u github.com/kataras/iris
 
@@ -119,7 +119,7 @@ Example code:
         usersRoutes := app.Party("/users", logThisMiddleware)
         {
             // Method GET: http://localhost:8080/users/42
-            usersRoutes.Get("/{id:int min(1)}", getUserByID)
+            usersRoutes.Get("/{id:uint64 min(1)}", getUserByID)
             // Method POST: http://localhost:8080/users/create
             usersRoutes.Post("/create", createUser)
         }
@@ -146,7 +146,7 @@ Example code:
     }
 
     func getUserByID(ctx iris.Context) {
-        userID := ctx.Params().Get("id") // Or convert directly using: .Values().GetInt/GetInt64 etc...
+        userID := ctx.Params().Get("id") // Or convert directly using: .Values().GetInt/GetUint64/GetInt64 etc...
         // your own db fetch here instead of user :=...
         user := User{Username: "username" + userID}
 
@@ -489,7 +489,7 @@ Example code:
     users := app.Party("/users", myAuthMiddlewareHandler)
 
     // http://myhost.com/users/42/profile
-    users.Get("/{id:int}/profile", userProfileHandler)
+    users.Get("/{id:uint64}/profile", userProfileHandler)
     // http://myhost.com/users/messages/1
     users.Get("/inbox/{id:int}", userMessageHandler)
 
@@ -548,8 +548,8 @@ Example code:
         app.Get("/donate", donateHandler, donateFinishHandler)
 
         // Pssst, don't forget dynamic-path example for more "magic"!
-        app.Get("/api/users/{userid:int min(1)}", func(ctx iris.Context) {
-            userID, err := ctx.Params().GetInt("userid")
+        app.Get("/api/users/{userid:uint64 min(1)}", func(ctx iris.Context) {
+            userID, err := ctx.Params().GetUint64("userid")
 
             if err != nil {
                 ctx.Writef("error while trying to parse userid parameter," +
@@ -622,8 +622,8 @@ Example code:
                     ctx.Writef("All users")
                 })
                 // http://v1.localhost:8080/api/users/42
-                usersAPI.Get("/{userid:int}", func(ctx iris.Context) {
-                    ctx.Writef("user with id: %s", ctx.Params().Get("userid"))
+                usersAPI.Get("/{userid:uint64}", func(ctx iris.Context) {
+                    ctx.Writef("user with id: %s", ctx.Params().GetUint64("userid"))
                 })
             }
         }
@@ -709,23 +709,71 @@ Standard macro types for parameters:
     | {param:string}         |
     +------------------------+
     string type
-    anything
+    anything (single path segmnent)
 
-    +------------------------+
-    | {param:int}            |
-    +------------------------+
+    +-------------------------------+
+    | {param:int}                   |
+    +-------------------------------+
     int type
-    only numbers (0-9)
+    -9223372036854775808 to 9223372036854775807 (x64) or -2147483648 to 2147483647 (x32), depends on the host arch
 
     +------------------------+
-    | {param:long}           |
+    | {param:int8}           |
+    +------------------------+
+    int8 type
+    -128 to 127
+
+    +------------------------+
+    | {param:int16}          |
+    +------------------------+
+    int16 type
+    -32768 to 32767
+
+    +------------------------+
+    | {param:int32}          |
+    +------------------------+
+    int32 type
+    -2147483648 to 2147483647
+
+    +------------------------+
+    | {param:int64}          |
     +------------------------+
     int64 type
-    only numbers (0-9)
+    -9223372036854775808 to 9223372036854775807
 
     +------------------------+
-    | {param:boolean}        |
+    | {param:uint}           |
     +------------------------+
+    uint type
+    0 to 18446744073709551615 (x64) or 0 to 4294967295 (x32)
+
+    +------------------------+
+    | {param:uint8}          |
+    +------------------------+
+    uint8 type
+    0 to 255
+
+    +------------------------+
+    | {param:uint16}         |
+    +------------------------+
+    uint16 type
+    0 to 65535
+
+    +------------------------+
+    | {param:uint32}          |
+    +------------------------+
+    uint32 type
+    0 to 4294967295
+
+    +------------------------+
+    | {param:uint64}         |
+    +------------------------+
+    uint64 type
+    0 to 18446744073709551615
+
+    +---------------------------------+
+    | {param:bool} or {param:boolean} |
+    +---------------------------------+
     bool type
     only "1" or "t" or "T" or "TRUE" or "true" or "True"
     or "0" or "f" or "F" or "FALSE" or "false" or "False"
@@ -751,8 +799,8 @@ Standard macro types for parameters:
     | {param:path}           |
     +------------------------+
     path type
-    anything, should be the last part, more than one path segment,
-    i.e: /path1/path2/path3 , ctx.Params().Get("param") == "/path1/path2/path3"
+    anything, should be the last part, can be more than one path segment,
+    i.e: "/test/*param" and request: "/test/path1/path2/path3" , ctx.Params().Get("param") == "path1/path2/path3"
 
 if type is missing then parameter's type is defaulted to string, so
 {param} == {param:string}.
@@ -770,16 +818,18 @@ you are able to register your own too!.
 Register a named path parameter function:
 
 
-    app.Macros().Int.RegisterFunc("min", func(argument int) func(paramValue string) bool {
-        [...]
-        return true/false -> true means valid.
+    app.Macros().Get("int").RegisterFunc("min", func(argument int) func(paramValue int) bool {
+        return func(paramValue int) bool {
+            [...]
+            return true/false -> true means valid.
+        }
     })
 
 at the func(argument ...) you can have any standard type, it will be validated before the server starts
 so don't care about performance here, the only thing it runs at serve time is the returning func(paramValue string) bool.
 
     {param:string equal(iris)} , "iris" will be the argument here:
-    app.Macros().String.RegisterFunc("equal", func(argument string) func(paramValue string) bool {
+    app.Macros().Get("string").RegisterFunc("equal", func(argument string) func(paramValue string) bool {
         return func(paramValue string){ return argument == paramValue }
     })
 
@@ -795,38 +845,34 @@ Example Code:
 	// Let's register our first macro attached to int macro type.
 	// "min" = the function
 	// "minValue" = the argument of the function
-	// func(string) bool = the macro's path parameter evaluator, this executes in serve time when
-	// a user requests a path which contains the :int macro type with the min(...) macro parameter function.
-	app.Macros().Int.RegisterFunc("min", func(minValue int) func(string) bool {
+	// func(<T>) bool = the macro's path parameter evaluator, this executes in serve time when
+	// a user requests a path which contains the int macro type with the min(...) macro parameter function.
+	app.Macros().Get("int").RegisterFunc("min", func(minValue int) func(int) bool {
 		// do anything before serve here [...]
 		// at this case we don't need to do anything
-		return func(paramValue string) bool {
-			n, err := strconv.Atoi(paramValue)
-			if err != nil {
-				return false
-			}
-			return n >= minValue
+		return func(paramValue int) bool {
+			return paramValue >= minValue
 		}
 	})
 
 	// http://localhost:8080/profile/id>=1
 	// this will throw 404 even if it's found as route on : /profile/0, /profile/blabla, /profile/-1
 	// macro parameter functions are optional of course.
-	app.Get("/profile/{id:int min(1)}", func(ctx iris.Context) {
+	app.Get("/profile/{id:uint64 min(1)}", func(ctx iris.Context) {
 		// second parameter is the error but it will always nil because we use macros,
 		// the validaton already happened.
-		id, _ := ctx.Params().GetInt("id")
+		id, _ := ctx.Params().GetUint64("id")
 		ctx.Writef("Hello id: %d", id)
 	})
 
 	// to change the error code per route's macro evaluator:
-	app.Get("/profile/{id:int min(1)}/friends/{friendid:int min(1) else 504}", func(ctx iris.Context) {
-		id, _ := ctx.Params().GetInt("id")
-		friendid, _ := ctx.Params().GetInt("friendid")
+	app.Get("/profile/{id:uint64 min(1)}/friends/{friendid:uint64 min(1) else 504}", func(ctx iris.Context) {
+		id, _ := ctx.Params().GetUint64("id")
+		friendid, _ := ctx.Params().GetUint64("friendid")
 		ctx.Writef("Hello id: %d looking for friend id: ", id, friendid)
 	}) // this will throw e 504 error code instead of 404 if all route's macros not passed.
 
-	// http://localhost:8080/game/a-zA-Z/level/0-9
+	// http://localhost:8080/game/a-zA-Z/level/42
 	// remember, alphabetical is lowercase or uppercase letters only.
 	app.Get("/game/{name:alphabetical}/level/{level:int}", func(ctx iris.Context) {
 		ctx.Writef("name: %s | level: %s", ctx.Params().Get("name"), ctx.Params().Get("level"))
@@ -855,11 +901,6 @@ Example Code:
 }
 
 
-
-A path parameter name should contain only alphabetical letters, symbols, containing '_' and numbers are NOT allowed.
-If route failed to be registered, the app will panic without any warnings
-if you didn't catch the second return value(error) on .Handle/.Get....
-
 Last, do not confuse ctx.Values() with ctx.Params().
 Path parameter's values goes to ctx.Params() and context's local storage
 that can be used to communicate between handlers and middleware(s) goes to

go.mod

@@ -0,0 +1,68 @@
+module github.com/kataras/iris
+
+require (
+	github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7 // indirect
+	github.com/BurntSushi/toml v0.3.1
+	github.com/Joker/jade v0.7.0
+	github.com/Shopify/goreferrer v0.0.0-20180807163728-b9777dc9f9cc
+	github.com/ajg/form v0.0.0-20160822230020-523a5da1a92f // indirect
+	github.com/aymerick/raymond v2.0.2+incompatible
+	github.com/boltdb/bolt v1.3.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/dgraph-io/badger v1.5.4
+	github.com/dgryski/go-farm v0.0.0-20180109070241-2de33835d102 // indirect
+	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385
+	github.com/etcd-io/bbolt v1.3.0
+	github.com/fatih/structs v1.0.0
+	github.com/flosch/pongo2 v0.0.0-20180809100617-24195e6d38b0
+	github.com/gavv/monotime v0.0.0-20171021193802-6f8212e8d10d // indirect
+	github.com/gomodule/redigo v2.0.0+incompatible
+	github.com/google/go-querystring v1.0.0 // indirect
+	github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c // indirect
+	github.com/gorilla/websocket v1.4.0
+	github.com/imkira/go-interpol v1.1.0 // indirect
+	github.com/iris-contrib/formBinder v0.0.0-20171010160137-ad9fb86c356f
+	github.com/iris-contrib/go.uuid v2.0.0+incompatible
+	github.com/iris-contrib/httpexpect v0.0.0-20180314041918-ebe99fcebbce
+	github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0
+	github.com/json-iterator/go v1.1.5
+	github.com/jtolds/gls v4.2.1+incompatible // indirect
+	github.com/juju/errors v0.0.0-20180806074554-22422dad46e1 // indirect
+	github.com/juju/loggo v0.0.0-20180524022052-584905176618 // indirect
+	github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073 // indirect
+	github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 // indirect
+	github.com/kataras/golog v0.0.0-20180321173939-03be10146386
+	github.com/kataras/pio v0.0.0-20180511174041-a9733b5b6b83 // indirect
+	github.com/klauspost/compress v1.4.0
+	github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e // indirect
+	github.com/mattn/go-colorable v0.0.9 // indirect
+	github.com/mattn/go-isatty v0.0.4 // indirect
+	github.com/microcosm-cc/bluemonday v1.0.1
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.1 // indirect
+	github.com/moul/http2curl v0.0.0-20170919181001-9ac6cf4d929b // indirect
+	github.com/onsi/gomega v1.4.2 // indirect
+	github.com/pkg/errors v0.8.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/ryanuber/columnize v2.1.0+incompatible
+	github.com/sergi/go-diff v1.0.0 // indirect
+	github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 // indirect
+	github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d // indirect
+	github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a // indirect
+	github.com/stretchr/testify v1.2.2 // indirect
+	github.com/valyala/bytebufferpool v1.0.0
+	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
+	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
+	github.com/xeipuuv/gojsonschema v0.0.0-20180816142147-da425ebb7609 // indirect
+	github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 // indirect
+	github.com/yudai/gojsondiff v1.0.0 // indirect
+	github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 // indirect
+	github.com/yudai/pp v2.0.1+incompatible // indirect
+	golang.org/x/crypto v0.0.0-20180927165925-5295e8364332
+	golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3 // indirect
+	golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 // indirect
+	gopkg.in/ini.v1 v1.38.3 // indirect
+	gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce // indirect
+	gopkg.in/russross/blackfriday.v2 v2.0.0+incompatible
+	gopkg.in/yaml.v2 v2.2.1
+)

go.sum

@@ -0,0 +1,148 @@
+github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7 h1:PqzgE6kAMi81xWQA2QIVxjWkFHptGgC547vchpUbtFo=
+github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/Joker/jade v0.7.0 h1:9sEpF/GAfkn0D0n+x8/SVGpxvdjIStsyPaTvtXW6z/U=
+github.com/Joker/jade v0.7.0/go.mod h1:R1kvvouJogE6SnKqO5Qw3j2rCE2T9HjIWaFeSET/qMQ=
+github.com/Shopify/goreferrer v0.0.0-20180807163728-b9777dc9f9cc h1:zZYkIbeMNcH1lhztdVxy4+Ykk8NoMhqUfSigsrT/x7Y=
+github.com/Shopify/goreferrer v0.0.0-20180807163728-b9777dc9f9cc/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
+github.com/ajg/form v0.0.0-20160822230020-523a5da1a92f h1:zvClvFQwU++UpIUBGC8YmDlfhUrweEy1R1Fj1gu5iIM=
+github.com/ajg/form v0.0.0-20160822230020-523a5da1a92f/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
+github.com/aymerick/raymond v2.0.2+incompatible h1:VEp3GpgdAnv9B2GFyTvqgcKvY+mfKMjPOA3SbKLtnU0=
+github.com/aymerick/raymond v2.0.2+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
+github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgraph-io/badger v1.5.4 h1:gVTrpUTbbr/T24uvoCaqY2KSHfNLVGm0w+hbee2HMeg=
+github.com/dgraph-io/badger v1.5.4/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ=
+github.com/dgryski/go-farm v0.0.0-20180109070241-2de33835d102 h1:afESQBXJEnj3fu+34X//E8Wg3nEbMJxJkwSc0tPePK0=
+github.com/dgryski/go-farm v0.0.0-20180109070241-2de33835d102/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 h1:clC1lXBpe2kTj2VHdaIu9ajZQe4kcEY9j0NsnDDBZ3o=
+github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
+github.com/etcd-io/bbolt v1.3.0 h1:ec0U3x11Mk69A8YwQyZEhNaUqHkQSv2gDR3Bioz5DfU=
+github.com/etcd-io/bbolt v1.3.0/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
+github.com/fatih/structs v1.0.0 h1:BrX964Rv5uQ3wwS+KRUAJCBBw5PQmgJfJ6v4yly5QwU=
+github.com/fatih/structs v1.0.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
+github.com/flosch/pongo2 v0.0.0-20180809100617-24195e6d38b0 h1:ZHx2BEERvWkuwuE7qWN9TuRxucHDH2JrsvneZjVJfo0=
+github.com/flosch/pongo2 v0.0.0-20180809100617-24195e6d38b0/go.mod h1:rE0ErqqBaMcp9pzj8JxV1GcfDBpuypXYxlR1c37AUwg=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/gavv/monotime v0.0.0-20171021193802-6f8212e8d10d h1:oYXrtNhqNKL1dVtKdv8XUq5zqdGVFNQ0/4tvccXZOLM=
+github.com/gavv/monotime v0.0.0-20171021193802-6f8212e8d10d/go.mod h1:vmp8DIyckQMXOPl0AQVHt+7n5h7Gb7hS6CUydiV8QeA=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
+github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c h1:16eHWuMGvCjSfgRJKqIzapE78onvvTbdi1rMkU00lZw=
+github.com/gopherjs/gopherjs v0.0.0-20180825215210-0210a2f0f73c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
+github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
+github.com/iris-contrib/formBinder v0.0.0-20171010160137-ad9fb86c356f h1:WgD6cqCSncBgkftw34mSPlMKU5JgoruAomW/SJtRrGU=
+github.com/iris-contrib/formBinder v0.0.0-20171010160137-ad9fb86c356f/go.mod h1:i8kTYUOEstd/S8TG0ChTXQdf4ermA/e8vJX0+QruD9w=
+github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3pB80+OQg2qf6c8BfWE=
+github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
+github.com/iris-contrib/httpexpect v0.0.0-20180314041918-ebe99fcebbce h1:q8Ka/exfHNgK7izJE+aUOZd7KZXJ7oQbnJWiZakEiMo=
+github.com/iris-contrib/httpexpect v0.0.0-20180314041918-ebe99fcebbce/go.mod h1:VER17o2JZqquOx41avolD/wMGQSFEFBKWmhag9/RQRY=
+github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0 h1:Kyp9KiXwsyZRTeoNjgVCrWks7D8ht9+kg6yCjh8K97o=
+github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0/go.mod h1:pMCz62A0xJL6I+umB2YTlFRwWXaDFA0jy+5HzGiJjqI=
+github.com/json-iterator/go v1.1.5 h1:gL2yXlmiIo4+t+y32d4WGwOjKGYcGOuyrg46vadswDE=
+github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/jtolds/gls v4.2.1+incompatible h1:fSuqC+Gmlu6l/ZYAoZzx2pyucC8Xza35fpRVWLVmUEE=
+github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/juju/errors v0.0.0-20180806074554-22422dad46e1 h1:wnhMXidtb70kDZCeLt/EfsVtkXS5c8zLnE9y/6DIRAU=
+github.com/juju/errors v0.0.0-20180806074554-22422dad46e1/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q=
+github.com/juju/loggo v0.0.0-20180524022052-584905176618 h1:MK144iBQF9hTSwBW/9eJm034bVoG30IshVm688T2hi8=
+github.com/juju/loggo v0.0.0-20180524022052-584905176618/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U=
+github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073 h1:WQM1NildKThwdP7qWrNAFGzp4ijNLw8RlgENkaI4MJs=
+github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073/go.mod h1:63prj8cnj0tU0S9OHjGJn+b1h0ZghCndfnbQolrYTwA=
+github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 h1:uC1QfSlInpQF+M0ao65imhwqKnz3Q2z/d8PWZRMQvDM=
+github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
+github.com/kataras/golog v0.0.0-20180321173939-03be10146386 h1:VT6AeCHO/mc+VedKBMhoqb5eAK8B1i9F6nZl7EGlHvA=
+github.com/kataras/golog v0.0.0-20180321173939-03be10146386/go.mod h1:PcaEvfvhGsqwXZ6S3CgCbmjcp+4UDUh2MIfF2ZEul8M=
+github.com/kataras/pio v0.0.0-20180511174041-a9733b5b6b83 h1:NoJ+fI58ptwrPc1blX116i+5xWGAY/2TJww37AN8X54=
+github.com/kataras/pio v0.0.0-20180511174041-a9733b5b6b83/go.mod h1:NV88laa9UiiDuX9AhMbDPkGYSPugBOV6yTZB1l2K9Z0=
+github.com/klauspost/compress v1.4.0 h1:8nsMz3tWa9SWWPL60G1V6CUsf4lLjWLTNEtibhe8gh8=
+github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e h1:+lIPJOWl+jSiJOc70QXJ07+2eg2Jy2EC7Mi11BWujeM=
+github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/microcosm-cc/bluemonday v1.0.1 h1:SIYunPjnlXcW+gVfvm0IlSeR5U3WZUOLfVmqg85Go44=
+github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/moul/http2curl v0.0.0-20170919181001-9ac6cf4d929b h1:Pip12xNtMvEFUBF4f8/b5yRXj94LLrNdLWELfOr2KcY=
+github.com/moul/http2curl v0.0.0-20170919181001-9ac6cf4d929b/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
+github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.2 h1:3mYCb7aPxS/RU7TI1y4rkEn1oKmPRjNJLNEXgw7MH2I=
+github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/ryanuber/columnize v2.1.0+incompatible h1:j1Wcmh8OrK4Q7GXY+V7SVSY8nUWQxHW5TkBe7YUl+2s=
+github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 h1:/vdW8Cb7EXrkqWGufVMES1OH2sU9gKVb2n9/1y5NMBY=
+github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a h1:JSvGDIbmil4Ui/dDdFBExb7/cmkNjyX5F97oglmvCDo=
+github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v0.0.0-20180816142147-da425ebb7609 h1:BcMExZAULPkihVZ7UJXK7t8rwGqisXFw75tILnafhBY=
+github.com/xeipuuv/gojsonschema v0.0.0-20180816142147-da425ebb7609/go.mod h1:5yf86TLmAcydyeJq5YvxkGPE2fm/u4myDekKRoLuqhs=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
+github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
+github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
+github.com/yudai/pp v2.0.1+incompatible h1:Q4//iY4pNF6yPLZIigmvcl7k/bPgrcTPIFIcmawg5bI=
+github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
+golang.org/x/crypto v0.0.0-20180927165925-5295e8364332 h1:hvQVdF6P9DX4OiKA5tpehlG6JsgzmyQiThG7q5Bn3UQ=
+golang.org/x/crypto v0.0.0-20180927165925-5295e8364332/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3 h1:dgd4x4kJt7G4k4m93AYLzM8Ni6h2qLTfh9n9vXJT3/0=
+golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 h1:O33LKL7WyJgjN9CvxfTIomjIClbd/Kq86/iipowHQU0=
+golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/ini.v1 v1.38.3 h1:ourkRZgR6qjJYoec9lYhX4+nuN1tEbV34dQEQ3IRk9U=
+gopkg.in/ini.v1 v1.38.3/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce h1:xcEWjVhvbDy+nHP67nPDDpbYrY+ILlfndk4bRioVHaU=
+gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
+gopkg.in/russross/blackfriday.v2 v2.0.0+incompatible h1:l1Mna0cVh8WlpyB8uFtc2c+5cdvrI5CDyuwTgIChojI=
+gopkg.in/russross/blackfriday.v2 v2.0.0+incompatible/go.mod h1:6sSBNz/GtOm/pJTuh5UmBK2ZHfmnxGbl2NZg1UliSOI=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

hero/di.go

@@ -8,6 +8,17 @@ import (
 
 func init() {
 	di.DefaultHijacker = func(fieldOrFuncInput reflect.Type) (*di.BindObject, bool) {
+		// if IsExpectingStore(fieldOrFuncInput) {
+		// 	return &di.BindObject{
+		// 		Type:     memstoreTyp,
+		// 		BindType: di.Dynamic,
+		// 		ReturnValue: func(ctxValue []reflect.Value) reflect.Value {
+		// 			// return ctxValue[0].MethodByName("Params").Call(di.EmptyIn)[0]
+		// 			return ctxValue[0].MethodByName("Params").Call(di.EmptyIn)[0].Field(0) // the Params' memstore.Store.
+		// 		},
+		// 	}, true
+		// }
+
 		if !IsContext(fieldOrFuncInput) {
 			return nil, false
 		}

hero/di/func.go

@@ -132,9 +132,8 @@ func (s *FuncInjector) addValue(inputIndex int, value reflect.Value) bool {
 	}
 
 	if b.IsAssignable(inTyp) {
-		// println(inTyp.String() + " is assignable to " + val.Type().String())
 		// fmt.Printf("binded input index: %d for type: %s and value: %v with pointer: %v\n",
-		// 	i, b.Type.String(), value.String(), val.Pointer())
+		// 	i, b.Type.String(), inTyp.String(), inTyp.Pointer())
 		s.inputs = append(s.inputs, &targetFuncInput{
 			InputIndex: inputIndex,
 			Object:     &b,
@@ -194,8 +193,8 @@ func (s *FuncInjector) Inject(in *[]reflect.Value, ctx ...reflect.Value) {
 	args := *in
 	for _, input := range s.inputs {
 		input.Object.Assign(ctx, func(v reflect.Value) {
-			// fmt.Printf("assign input index: %d for value: %v\n",
-			// 	input.InputIndex, v.String())
+			// fmt.Printf("assign input index: %d for value: %v of type: %s\n",
+			// 	input.InputIndex, v.String(), v.Type().Name())
 			args[input.InputIndex] = v
 		})
 

hero/di/object.go

@@ -101,6 +101,11 @@ func MakeReturnValue(fn reflect.Value, goodFunc TypeChecker) (func([]reflect.Val
 		if !v.IsValid() {
 			return zeroOutVal
 		}
+		// if v.String() == "<interface {} Value>" {
+		// 	println("di/object.go: " + v.String())
+		// 	// println("di/object.go: because it's interface{} it should be returned as: " + v.Elem().Type().String() + " and its value: " + v.Elem().Interface().(string))
+		// 	return v.Elem()
+		// }
 		return v
 	}
 

hero/di/reflect.go

@@ -54,6 +54,7 @@ func IsZero(v reflect.Value) bool {
 		// if can't interface, i.e return value from unexported field or method then return false
 		return false
 	}
+
 	zero := reflect.Zero(v.Type())
 	return v.Interface() == zero.Interface()
 }
@@ -62,7 +63,10 @@ func IsZero(v reflect.Value) bool {
 // If "v" is a nil pointer, Indirect returns a zero Value.
 // If "v" is not a pointer, Indirect returns v.
 func IndirectValue(v reflect.Value) reflect.Value {
-	return reflect.Indirect(v)
+	if k := v.Kind(); k == reflect.Ptr { //|| k == reflect.Interface {
+		return v.Elem()
+	}
+	return v
 }
 
 // ValueOf returns the reflect.Value of "o".
@@ -123,6 +127,11 @@ func equalTypes(got reflect.Type, expected reflect.Type) bool {
 		// fmt.Printf("expected interface = %s and got to set on the arg is: %s\n", expected.String(), got.String())
 		return got.Implements(expected)
 	}
+
+	// if got.String() == "interface {}"  {
+	// 	return true
+	// }
+
 	return false
 }
 
@@ -161,7 +170,6 @@ func lookupFields(elemTyp reflect.Type, skipUnexported bool, parentIndex []int)
 
 	for i, n := 0, elemTyp.NumField(); i < n; i++ {
 		f := elemTyp.Field(i)
-
 		if IndirectType(f.Type).Kind() == reflect.Struct &&
 			!structFieldIgnored(f) {
 			fields = append(fields, lookupFields(f.Type, skipUnexported, append(parentIndex, i))...)

hero/handler.go

@@ -5,13 +5,15 @@ import (
 	"reflect"
 	"runtime"
 
+	"github.com/kataras/iris/context"
 	"github.com/kataras/iris/hero/di"
 
 	"github.com/kataras/golog"
-	"github.com/kataras/iris/context"
 )
 
-var contextTyp = reflect.TypeOf((*context.Context)(nil)).Elem()
+var (
+	contextTyp = reflect.TypeOf((*context.Context)(nil)).Elem()
+)
 
 // IsContext returns true if the "inTyp" is a type of Context.
 func IsContext(inTyp reflect.Type) bool {
@@ -70,7 +72,7 @@ func makeHandler(handler interface{}, values ...reflect.Value) (context.Handler,
 		// is invalid when input len and values are not match
 		// or their types are not match, we will take look at the
 		// second statement, here we will re-try it
-		// using binders for path parameters: string, int, int64, bool.
+		// using binders for path parameters: string, int, int64, uint8, uint64, bool and so on.
 		// We don't have access to the path, so neither to the macros here,
 		// but in mvc. So we have to do it here.
 		if valid = funcInjector.Retry(new(params).resolve); !valid {

hero/param.go

@@ -19,50 +19,8 @@ type params struct {
 
 func (p *params) resolve(index int, typ reflect.Type) (reflect.Value, bool) {
 	currentParamIndex := p.next
-	v, ok := resolveParam(currentParamIndex, typ)
+	v, ok := context.ParamResolverByTypeAndIndex(typ, currentParamIndex)
 
 	p.next = p.next + 1
 	return v, ok
 }
-
-func resolveParam(currentParamIndex int, typ reflect.Type) (reflect.Value, bool) {
-	var fn interface{}
-
-	switch typ.Kind() {
-	case reflect.Int:
-		fn = func(ctx context.Context) int {
-			// the second "ok/found" check is not necessary,
-			// because even if the entry didn't found on that "index"
-			// it will return an empty entry which will return the
-			// default value passed from the xDefault(def) because its `ValueRaw` is nil.
-			entry, _ := ctx.Params().GetEntryAt(currentParamIndex)
-			v, _ := entry.IntDefault(0)
-			return v
-		}
-	case reflect.Int64:
-		fn = func(ctx context.Context) int64 {
-			entry, _ := ctx.Params().GetEntryAt(currentParamIndex)
-			v, _ := entry.Int64Default(0)
-
-			return v
-		}
-	case reflect.Bool:
-		fn = func(ctx context.Context) bool {
-			entry, _ := ctx.Params().GetEntryAt(currentParamIndex)
-			v, _ := entry.BoolDefault(false)
-			return v
-		}
-	case reflect.String:
-		fn = func(ctx context.Context) string {
-			entry, _ := ctx.Params().GetEntryAt(currentParamIndex)
-			// print(entry.Key + " with index of: ")
-			// print(currentParamIndex)
-			// println(" and value: " + entry.String())
-			return entry.String()
-		}
-	default:
-		return reflect.Value{}, false
-	}
-
-	return reflect.ValueOf(fn), true
-}

httptest/httptest.go

@@ -84,8 +84,7 @@ func New(t *testing.T, app *iris.Application, setters ...OptionSetter) *httpexpe
 		setter.Set(conf)
 	}
 
-	// set the logger or disable it (default) and disable the updater (for any case).
-	app.Configure(iris.WithoutVersionChecker)
+	// set the logger or disable it (default).
 	app.Logger().SetLevel(conf.LogLevel)
 
 	if err := app.Build(); err != nil {

iris.go

@@ -17,7 +17,6 @@ import (
 	// core packages, needed to build the application
 	"github.com/kataras/iris/core/errors"
 	"github.com/kataras/iris/core/host"
-	"github.com/kataras/iris/core/maintenance"
 	"github.com/kataras/iris/core/netutil"
 	"github.com/kataras/iris/core/router"
 	// handlerconv conversions
@@ -34,7 +33,7 @@ import (
 
 var (
 	// Version is the current version number of the Iris Web Framework.
-	Version = maintenance.Version
+	Version = "11.0.0"
 )
 
 // HTTP status codes as registered with IANA.
@@ -58,13 +57,13 @@ const (
 	StatusAlreadyReported      = 208 // RFC 5842, 7.1
 	StatusIMUsed               = 226 // RFC 3229, 10.4.1
 
-	StatusMultipleChoices   = 300 // RFC 7231, 6.4.1
-	StatusMovedPermanently  = 301 // RFC 7231, 6.4.2
-	StatusFound             = 302 // RFC 7231, 6.4.3
-	StatusSeeOther          = 303 // RFC 7231, 6.4.4
-	StatusNotModified       = 304 // RFC 7232, 4.1
-	StatusUseProxy          = 305 // RFC 7231, 6.4.5
-	_                       = 306 // RFC 7231, 6.4.6 (Unused)
+	StatusMultipleChoices  = 300 // RFC 7231, 6.4.1
+	StatusMovedPermanently = 301 // RFC 7231, 6.4.2
+	StatusFound            = 302 // RFC 7231, 6.4.3
+	StatusSeeOther         = 303 // RFC 7231, 6.4.4
+	StatusNotModified      = 304 // RFC 7232, 4.1
+	StatusUseProxy         = 305 // RFC 7231, 6.4.5
+
 	StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
 	StatusPermanentRedirect = 308 // RFC 7538, 3
 
@@ -87,6 +86,7 @@ const (
 	StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
 	StatusExpectationFailed            = 417 // RFC 7231, 6.5.14
 	StatusTeapot                       = 418 // RFC 7168, 2.3.3
+	StatusMisdirectedRequest           = 421 // RFC 7540, 9.1.2
 	StatusUnprocessableEntity          = 422 // RFC 4918, 11.2
 	StatusLocked                       = 423 // RFC 4918, 11.3
 	StatusFailedDependency             = 424 // RFC 4918, 11.4
@@ -761,7 +761,7 @@ func (app *Application) Build() error {
 			// create the request handler, the default routing handler
 			routerHandler := router.NewDefaultHandler()
 
-			rp.Describe("router: %v", app.Router.BuildRouter(app.ContextPool, routerHandler, app.APIBuilder))
+			rp.Describe("router: %v", app.Router.BuildRouter(app.ContextPool, routerHandler, app.APIBuilder, false))
 			// re-build of the router from outside can be done with;
 			// app.RefreshRouter()
 		}
@@ -810,10 +810,6 @@ func (app *Application) Run(serve Runner, withOrWithout ...Configurator) error {
 	app.Configure(withOrWithout...)
 	app.logger.Debugf("Application: running using %d host(s)", len(app.Hosts)+1)
 
-	if !app.config.DisableVersionChecker {
-		go maintenance.Start()
-	}
-
 	// this will block until an error(unless supervisor's DeferFlow called from a Task).
 	err := serve(app)
 	if err != nil {

macro/AUTHORS

@@ -0,0 +1,4 @@
+# This is the official list of Iris Macro and Route path interpreter authors for copyright
+# purposes.
+
+Gerasimos Maropoulos <kataras2006@hotmail.com>

macro/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2017-2018 The Iris Macro and Route path interpreter. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Iris nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

macro/handler/handler.go

@@ -0,0 +1,56 @@
+// Package handler is the highest level module of the macro package which makes use the rest of the macro package,
+// it is mainly used, internally, by the router package.
+package handler
+
+import (
+	"github.com/kataras/iris/context"
+	"github.com/kataras/iris/macro"
+)
+
+// CanMakeHandler reports whether a macro template needs a special macro's evaluator handler to be validated
+// before procceed to the next handler(s).
+// If the template does not contain any dynamic attributes and a special handler is NOT required
+// then it returns false.
+func CanMakeHandler(tmpl macro.Template) (needsMacroHandler bool) {
+	if len(tmpl.Params) == 0 {
+		return
+	}
+
+	// check if we have params like: {name:string} or {name} or {anything:path} without else keyword or any functions used inside these params.
+	// 1. if we don't have, then we don't need to add a handler before the main route's handler (as I said, no performance if macro is not really used)
+	// 2. if we don't have any named params then we don't need a handler too.
+	for _, p := range tmpl.Params {
+		if p.CanEval() {
+			// if at least one needs it, then create the handler.
+			needsMacroHandler = true
+			break
+		}
+	}
+
+	return
+}
+
+// MakeHandler creates and returns a handler from a macro template, the handler evaluates each of the parameters if necessary at all.
+// If the template does not contain any dynamic attributes and a special handler is NOT required
+// then it returns a nil handler.
+func MakeHandler(tmpl macro.Template) context.Handler {
+	if !CanMakeHandler(tmpl) {
+		return nil
+	}
+
+	return func(ctx context.Context) {
+		for _, p := range tmpl.Params {
+			if !p.CanEval() {
+				continue // allow.
+			}
+
+			if !p.Eval(ctx.Params().Get(p.Name), &ctx.Params().Store) {
+				ctx.StatusCode(p.ErrCode)
+				ctx.StopExecution()
+				return
+			}
+		}
+		// if all passed, just continue.
+		ctx.Next()
+	}
+}

macro/handler/handler_test.go

@@ -0,0 +1,41 @@
+package handler
+
+import (
+	"testing"
+
+	"github.com/kataras/iris/macro"
+)
+
+func TestCanMakeHandler(t *testing.T) {
+	tests := []struct {
+		src          string
+		needsHandler bool
+	}{
+		{"/static/static", false},
+		{"/{myparam}", false},
+		{"/{myparam min(1)}", true},
+		{"/{myparam else 500}", true},
+		{"/{myparam else 404}", false},
+		{"/{myparam:string}/static", false},
+		{"/{myparam:int}", true},
+		{"/static/{myparam:int}/static", true},
+		{"/{myparam:path}", false},
+		{"/{myparam:path min(1) else 404}", true},
+	}
+
+	availableMacros := *macro.Defaults
+	for i, tt := range tests {
+		tmpl, err := macro.Parse(tt.src, availableMacros)
+		if err != nil {
+			t.Fatalf("[%d] '%s' failed to be parsed: %v", i, tt.src, err)
+		}
+
+		if got := CanMakeHandler(tmpl); got != tt.needsHandler {
+			if tt.needsHandler {
+				t.Fatalf("[%d] '%s' expected to be able to generate an evaluator handler instead of a nil one", i, tt.src)
+			} else {
+				t.Fatalf("[%d] '%s' should not need an evaluator handler", i, tt.src)
+			}
+		}
+	}
+}

macro/interpreter/ast/ast.go

@@ -0,0 +1,132 @@
+package ast
+
+type (
+	// ParamType holds the necessary information about a parameter type for the parser to lookup for.
+	ParamType interface {
+		// The name of the parameter type.
+		// Indent should contain the characters for the parser.
+		Indent() string
+	}
+
+	// MasterParamType if implemented and its `Master()` returns true then empty type param will be translated to this param type.
+	// Also its functions will be available to the rest of the macro param type's funcs.
+	//
+	// Only one Master is allowed.
+	MasterParamType interface {
+		ParamType
+		Master() bool
+	}
+
+	// TrailingParamType if implemented and its `Trailing()` returns true
+	// then it should be declared at the end of a route path and can accept any trailing path segment as one parameter.
+	TrailingParamType interface {
+		ParamType
+		Trailing() bool
+	}
+
+	// AliasParamType if implemeneted nad its `Alias()` returns a non-empty string
+	// then the param type can be written with that string literal too.
+	AliasParamType interface {
+		ParamType
+		Alias() string
+	}
+)
+
+// IsMaster returns true if the "pt" param type is a master one.
+func IsMaster(pt ParamType) bool {
+	p, ok := pt.(MasterParamType)
+	return ok && p.Master()
+}
+
+// IsTrailing returns true if the "pt" param type is a marked as trailing,
+// which should accept more than one path segment when in the end.
+func IsTrailing(pt ParamType) bool {
+	p, ok := pt.(TrailingParamType)
+	return ok && p.Trailing()
+}
+
+// HasAlias returns any alias of the "pt" param type.
+// If alias is empty or not found then it returns false as its second output argument.
+func HasAlias(pt ParamType) (string, bool) {
+	if p, ok := pt.(AliasParamType); ok {
+		alias := p.Alias()
+		return alias, len(alias) > 0
+	}
+
+	return "", false
+}
+
+// GetMasterParamType accepts a list of ParamType and returns its master.
+// If no `Master` specified:
+// and len(paramTypes) > 0 then it will return the first one,
+// otherwise it returns nil.
+func GetMasterParamType(paramTypes ...ParamType) ParamType {
+	for _, pt := range paramTypes {
+		if IsMaster(pt) {
+			return pt
+		}
+	}
+
+	if len(paramTypes) > 0 {
+		return paramTypes[0]
+	}
+
+	return nil
+}
+
+// LookupParamType accepts the string
+// representation of a parameter type.
+// Example:
+// "string"
+// "number" or "int"
+// "long" or "int64"
+// "uint8"
+// "uint64"
+// "boolean" or "bool"
+// "alphabetical"
+// "file"
+// "path"
+func LookupParamType(indentOrAlias string, paramTypes ...ParamType) (ParamType, bool) {
+	for _, pt := range paramTypes {
+		if pt.Indent() == indentOrAlias {
+			return pt, true
+		}
+
+		if alias, has := HasAlias(pt); has {
+			if alias == indentOrAlias {
+				return pt, true
+			}
+		}
+	}
+
+	return nil, false
+}
+
+// ParamStatement is a struct
+// which holds all the necessary information about a macro parameter.
+// It holds its type (string, int, alphabetical, file, path),
+// its source ({param:type}),
+// its name ("param"),
+// its attached functions by the user (min, max...)
+// and the http error code if that parameter
+// failed to be evaluated.
+type ParamStatement struct {
+	Src       string      // the original unparsed source, i.e: {id:int range(1,5) else 404}
+	Name      string      // id
+	Type      ParamType   // int
+	Funcs     []ParamFunc // range
+	ErrorCode int         // 404
+}
+
+// ParamFunc holds the name of a parameter's function
+// and its arguments (values)
+// A param func is declared with:
+// {param:int range(1,5)},
+// the range is the
+// param function name
+// the 1 and 5 are the two param function arguments
+// range(1,5)
+type ParamFunc struct {
+	Name string   // range
+	Args []string // ["1","5"]
+}

macro/interpreter/lexer/lexer.go

@@ -1,7 +1,7 @@
 package lexer
 
 import (
-	"github.com/kataras/iris/core/router/macro/interpreter/token"
+	"github.com/kataras/iris/macro/interpreter/token"
 )
 
 // Lexer helps us to read/scan characters of a source and resolve their token types.
@@ -179,7 +179,7 @@ func (l *Lexer) skipWhitespace() {
 
 func (l *Lexer) readIdentifier() string {
 	pos := l.pos
-	for isLetter(l.ch) {
+	for isLetter(l.ch) || isDigit(l.ch) {
 		l.readChar()
 	}
 	return l.input[pos:l.pos]

macro/interpreter/lexer/lexer_test.go

@@ -3,7 +3,7 @@ package lexer
 import (
 	"testing"
 
-	"github.com/kataras/iris/core/router/macro/interpreter/token"
+	"github.com/kataras/iris/macro/interpreter/token"
 )
 
 func TestNextToken(t *testing.T) {

macro/interpreter/parser/parser.go

@@ -5,15 +5,19 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/kataras/iris/core/router/macro/interpreter/ast"
-	"github.com/kataras/iris/core/router/macro/interpreter/lexer"
-	"github.com/kataras/iris/core/router/macro/interpreter/token"
+	"github.com/kataras/iris/macro/interpreter/ast"
+	"github.com/kataras/iris/macro/interpreter/lexer"
+	"github.com/kataras/iris/macro/interpreter/token"
 )
 
 // Parse takes a route "fullpath"
 // and returns its param statements
-// and an error on failure.
-func Parse(fullpath string) ([]*ast.ParamStatement, error) {
+// or an error if failed.
+func Parse(fullpath string, paramTypes []ast.ParamType) ([]*ast.ParamStatement, error) {
+	if len(paramTypes) == 0 {
+		return nil, fmt.Errorf("empty parameter types")
+	}
+
 	pathParts := strings.SplitN(fullpath, "/", -1)
 	p := new(ParamParser)
 	statements := make([]*ast.ParamStatement, 0)
@@ -28,14 +32,14 @@ func Parse(fullpath string) ([]*ast.ParamStatement, error) {
 		}
 
 		p.Reset(s)
-		stmt, err := p.Parse()
+		stmt, err := p.Parse(paramTypes)
 		if err != nil {
 			// exit on first error
 			return nil, err
 		}
 		// if we have param type path but it's not the last path part
-		if stmt.Type == ast.ParamTypePath && i < len(pathParts)-1 {
-			return nil, fmt.Errorf("param type 'path' should be lived only inside the last path segment, but was inside: %s", s)
+		if ast.IsTrailing(stmt.Type) && i < len(pathParts)-1 {
+			return nil, fmt.Errorf("%s: parameter type \"%s\" should be registered to the very last of a path", s, stmt.Type.Indent())
 		}
 
 		statements = append(statements, stmt)
@@ -77,15 +81,18 @@ const (
 	// per-parameter. An error code can be setted via
 	// the "else" keyword inside a route's path.
 	DefaultParamErrorCode = 404
-	// DefaultParamType when parameter type is missing use this param type, defaults to string
-	// and it should be remains unless earth split in two.
-	DefaultParamType = ast.ParamTypeString
 )
 
-func parseParamFuncArg(t token.Token) (a ast.ParamFuncArg, err error) {
-	if t.Type == token.INT {
-		return ast.ParamFuncArgToInt(t.Literal)
-	}
+// func parseParamFuncArg(t token.Token) (a ast.ParamFuncArg, err error) {
+// 	if t.Type == token.INT {
+// 		return ast.ParamFuncArgToInt(t.Literal)
+// 	}
+// 	// act all as strings here, because of int vs int64 vs uint64 and etc.
+// 	return t.Literal, nil
+// }
+
+func parseParamFuncArg(t token.Token) (a string, err error) {
+	// act all as strings here, because of int vs int64 vs uint64 and etc.
 	return t.Literal, nil
 }
 
@@ -96,14 +103,14 @@ func (p ParamParser) Error() error {
 	return nil
 }
 
-// Parse parses the p.src and returns its param statement
+// Parse parses the p.src based on the given param types and returns its param statement
 // and an error on failure.
-func (p *ParamParser) Parse() (*ast.ParamStatement, error) {
+func (p *ParamParser) Parse(paramTypes []ast.ParamType) (*ast.ParamStatement, error) {
 	l := lexer.New(p.src)
 
 	stmt := &ast.ParamStatement{
 		ErrorCode: DefaultParamErrorCode,
-		Type:      DefaultParamType,
+		Type:      ast.GetMasterParamType(paramTypes...),
 		Src:       p.src,
 	}
 
@@ -120,14 +127,15 @@ func (p *ParamParser) Parse() (*ast.ParamStatement, error) {
 
 		switch t.Type {
 		case token.LBRACE:
-			// name, alphabetical and _, param names are not allowed to contain any number.
+			// can accept only letter or number only.
 			nextTok := l.NextToken()
 			stmt.Name = nextTok.Literal
 		case token.COLON:
-			// type
+			// type can accept both letters and numbers but not symbols ofc.
 			nextTok := l.NextToken()
-			paramType := ast.LookupParamType(nextTok.Literal)
-			if paramType == ast.ParamTypeUnExpected {
+			paramType, found := ast.LookupParamType(nextTok.Literal, paramTypes...)
+
+			if !found {
 				p.appendErr("[%d:%d] unexpected parameter type: %s", t.Start, t.End, nextTok.Literal)
 			}
 			stmt.Type = paramType
@@ -143,25 +151,14 @@ func (p *ParamParser) Parse() (*ast.ParamStatement, error) {
 
 			argValTok := l.NextDynamicToken() // catch anything from "(" and forward, until ")", because we need to
 			// be able to use regex expression as a macro type's func argument too.
-			argVal, err := parseParamFuncArg(argValTok)
-			if err != nil {
-				p.appendErr("[%d:%d] expected param func argument to be a string or number but got %s", t.Start, t.End, argValTok.Literal)
-				continue
-			}
 
 			// fmt.Printf("argValTok: %#v\n", argValTok)
 			// fmt.Printf("argVal: %#v\n", argVal)
-			lastParamFunc.Args = append(lastParamFunc.Args, argVal)
+			lastParamFunc.Args = append(lastParamFunc.Args, argValTok.Literal)
 
 		case token.COMMA:
 			argValTok := l.NextToken()
-			argVal, err := parseParamFuncArg(argValTok)
-			if err != nil {
-				p.appendErr("[%d:%d] expected param func argument to be a string or number type but got %s", t.Start, t.End, argValTok.Literal)
-				continue
-			}
-
-			lastParamFunc.Args = append(lastParamFunc.Args, argVal)
+			lastParamFunc.Args = append(lastParamFunc.Args, argValTok.Literal)
 		case token.RPAREN:
 			stmt.Funcs = append(stmt.Funcs, lastParamFunc)
 			lastParamFunc = ast.ParamFunc{} // reset

macro/interpreter/parser/parser_test.go

@@ -6,9 +6,47 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/kataras/iris/core/router/macro/interpreter/ast"
+	"github.com/kataras/iris/macro/interpreter/ast"
 )
 
+type simpleParamType string
+
+func (pt simpleParamType) Indent() string { return string(pt) }
+
+type masterParamType simpleParamType
+
+func (pt masterParamType) Indent() string { return string(pt) }
+func (pt masterParamType) Master() bool   { return true }
+
+type wildcardParamType string
+
+func (pt wildcardParamType) Indent() string { return string(pt) }
+func (pt wildcardParamType) Trailing() bool { return true }
+
+type aliasedParamType []string
+
+func (pt aliasedParamType) Indent() string { return string(pt[0]) }
+func (pt aliasedParamType) Alias() string  { return pt[1] }
+
+var (
+	paramTypeString       = masterParamType("string")
+	paramTypeNumber       = aliasedParamType{"number", "int"}
+	paramTypeInt64        = aliasedParamType{"int64", "long"}
+	paramTypeUint8        = simpleParamType("uint8")
+	paramTypeUint64       = simpleParamType("uint64")
+	paramTypeBool         = aliasedParamType{"bool", "boolean"}
+	paramTypeAlphabetical = simpleParamType("alphabetical")
+	paramTypeFile         = simpleParamType("file")
+	paramTypePath         = wildcardParamType("path")
+)
+
+var testParamTypes = []ast.ParamType{
+	paramTypeString,
+	paramTypeNumber, paramTypeInt64, paramTypeUint8, paramTypeUint64,
+	paramTypeBool,
+	paramTypeAlphabetical, paramTypeFile, paramTypePath,
+}
+
 func TestParseParamError(t *testing.T) {
 	// fail
 	illegalChar := '$'
@@ -16,7 +54,7 @@ func TestParseParamError(t *testing.T) {
 	input := "{id" + string(illegalChar) + "int range(1,5) else 404}"
 	p := NewParamParser(input)
 
-	_, err := p.Parse()
+	_, err := p.Parse(testParamTypes)
 
 	if err == nil {
 		t.Fatalf("expecting not empty error on input '%s'", input)
@@ -30,9 +68,9 @@ func TestParseParamError(t *testing.T) {
 	//
 
 	// success
-	input2 := "{id:int range(1,5) else 404}"
+	input2 := "{id:uint64 range(1,5) else 404}"
 	p.Reset(input2)
-	_, err = p.Parse()
+	_, err = p.Parse(testParamTypes)
 
 	if err != nil {
 		t.Fatalf("expecting empty error on input '%s', but got: %s", input2, err.Error())
@@ -40,6 +78,16 @@ func TestParseParamError(t *testing.T) {
 	//
 }
 
+// mustLookupParamType same as `ast.LookupParamType` but it panics if "indent" does not match with a valid Param Type.
+func mustLookupParamType(indent string) ast.ParamType {
+	pt, found := ast.LookupParamType(indent, testParamTypes...)
+	if !found {
+		panic("param type '" + indent + "' is not part of the provided param types")
+	}
+
+	return pt
+}
+
 func TestParseParam(t *testing.T) {
 	tests := []struct {
 		valid             bool
@@ -49,27 +97,28 @@ func TestParseParam(t *testing.T) {
 			ast.ParamStatement{
 				Src:  "{id:int min(1) max(5) else 404}",
 				Name: "id",
-				Type: ast.ParamTypeInt,
+				Type: mustLookupParamType("number"),
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "min",
-						Args: []ast.ParamFuncArg{1}},
+						Args: []string{"1"}},
 					{
 						Name: "max",
-						Args: []ast.ParamFuncArg{5}},
+						Args: []string{"5"}},
 				},
 				ErrorCode: 404,
 			}}, // 0
 
 		{true,
 			ast.ParamStatement{
-				Src:  "{id:int range(1,5)}",
+				// test alias of int.
+				Src:  "{id:number range(1,5)}",
 				Name: "id",
-				Type: ast.ParamTypeInt,
+				Type: mustLookupParamType("number"),
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "range",
-						Args: []ast.ParamFuncArg{1, 5}},
+						Args: []string{"1", "5"}},
 				},
 				ErrorCode: 404,
 			}}, // 1
@@ -77,11 +126,11 @@ func TestParseParam(t *testing.T) {
 			ast.ParamStatement{
 				Src:  "{file:path contains(.)}",
 				Name: "file",
-				Type: ast.ParamTypePath,
+				Type: mustLookupParamType("path"),
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "contains",
-						Args: []ast.ParamFuncArg{"."}},
+						Args: []string{"."}},
 				},
 				ErrorCode: 404,
 			}}, // 2
@@ -89,35 +138,35 @@ func TestParseParam(t *testing.T) {
 			ast.ParamStatement{
 				Src:       "{username:alphabetical}",
 				Name:      "username",
-				Type:      ast.ParamTypeAlphabetical,
+				Type:      mustLookupParamType("alphabetical"),
 				ErrorCode: 404,
 			}}, // 3
 		{true,
 			ast.ParamStatement{
 				Src:       "{myparam}",
 				Name:      "myparam",
-				Type:      ast.ParamTypeString,
+				Type:      mustLookupParamType("string"),
 				ErrorCode: 404,
 			}}, // 4
 		{false,
 			ast.ParamStatement{
 				Src:       "{myparam_:thisianunexpected}",
 				Name:      "myparam_",
-				Type:      ast.ParamTypeUnExpected,
+				Type:      nil,
 				ErrorCode: 404,
 			}}, // 5
-		{false, // false because it will give an error of unexpeced token type with value 2
+		{true,
 			ast.ParamStatement{
 				Src:       "{myparam2}",
-				Name:      "myparam", // expected "myparam" because we don't allow integers to the parameter names.
-				Type:      ast.ParamTypeString,
+				Name:      "myparam2", // we now allow integers to the parameter names.
+				Type:      ast.GetMasterParamType(testParamTypes...),
 				ErrorCode: 404,
 			}}, // 6
 		{true,
 			ast.ParamStatement{
 				Src:  "{id:int even()}", // test param funcs without any arguments (LPAREN peek for RPAREN)
 				Name: "id",
-				Type: ast.ParamTypeInt,
+				Type: mustLookupParamType("number"),
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "even"},
@@ -126,25 +175,46 @@ func TestParseParam(t *testing.T) {
 			}}, // 7
 		{true,
 			ast.ParamStatement{
-				Src:       "{id:long else 404}",
+				Src:       "{id:int64 else 404}",
 				Name:      "id",
-				Type:      ast.ParamTypeLong,
+				Type:      mustLookupParamType("int64"),
 				ErrorCode: 404,
 			}}, // 8
 		{true,
 			ast.ParamStatement{
-				Src:       "{has:boolean else 404}",
-				Name:      "has",
-				Type:      ast.ParamTypeBoolean,
+				Src:       "{id:long else 404}", // backwards-compatible test.
+				Name:      "id",
+				Type:      mustLookupParamType("int64"),
 				ErrorCode: 404,
 			}}, // 9
+		{true,
+			ast.ParamStatement{
+				Src:       "{id:long else 404}",
+				Name:      "id",
+				Type:      mustLookupParamType("int64"), // backwards-compatible test of LookupParamType.
+				ErrorCode: 404,
+			}}, // 10
+		{true,
+			ast.ParamStatement{
+				Src:       "{has:bool else 404}",
+				Name:      "has",
+				Type:      mustLookupParamType("bool"),
+				ErrorCode: 404,
+			}}, // 11
+		{true,
+			ast.ParamStatement{
+				Src:       "{has:boolean else 404}", // backwards-compatible test.
+				Name:      "has",
+				Type:      mustLookupParamType("bool"),
+				ErrorCode: 404,
+			}}, // 12
 
 	}
 
 	p := new(ParamParser)
 	for i, tt := range tests {
 		p.Reset(tt.expectedStatement.Src)
-		resultStmt, err := p.Parse()
+		resultStmt, err := p.Parse(testParamTypes)
 
 		if tt.valid && err != nil {
 			t.Fatalf("tests[%d] - error %s", i, err.Error())
@@ -171,27 +241,27 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:  "{id:int min(1) max(5) else 404}",
 				Name: "id",
-				Type: ast.ParamTypeInt,
+				Type: paramTypeNumber,
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "min",
-						Args: []ast.ParamFuncArg{1}},
+						Args: []string{"1"}},
 					{
 						Name: "max",
-						Args: []ast.ParamFuncArg{5}},
+						Args: []string{"5"}},
 				},
 				ErrorCode: 404,
 			},
 			}}, // 0
-		{"/admin/{id:int range(1,5)}", true,
+		{"/admin/{id:uint64 range(1,5)}", true,
 			[]ast.ParamStatement{{
-				Src:  "{id:int range(1,5)}",
+				Src:  "{id:uint64 range(1,5)}",
 				Name: "id",
-				Type: ast.ParamTypeInt,
+				Type: paramTypeUint64,
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "range",
-						Args: []ast.ParamFuncArg{1, 5}},
+						Args: []string{"1", "5"}},
 				},
 				ErrorCode: 404,
 			},
@@ -200,11 +270,11 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:  "{file:path contains(.)}",
 				Name: "file",
-				Type: ast.ParamTypePath,
+				Type: paramTypePath,
 				Funcs: []ast.ParamFunc{
 					{
 						Name: "contains",
-						Args: []ast.ParamFuncArg{"."}},
+						Args: []string{"."}},
 				},
 				ErrorCode: 404,
 			},
@@ -213,7 +283,7 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:       "{username:alphabetical}",
 				Name:      "username",
-				Type:      ast.ParamTypeAlphabetical,
+				Type:      paramTypeAlphabetical,
 				ErrorCode: 404,
 			},
 			}}, // 3
@@ -221,7 +291,7 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:       "{myparam}",
 				Name:      "myparam",
-				Type:      ast.ParamTypeString,
+				Type:      paramTypeString,
 				ErrorCode: 404,
 			},
 			}}, // 4
@@ -229,15 +299,15 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:       "{myparam_:thisianunexpected}",
 				Name:      "myparam_",
-				Type:      ast.ParamTypeUnExpected,
+				Type:      nil,
 				ErrorCode: 404,
 			},
 			}}, // 5
-		{"/p2/{myparam2}", false, // false because it will give an error of unexpeced token type with value 2
+		{"/p2/{myparam2}", true,
 			[]ast.ParamStatement{{
 				Src:       "{myparam2}",
-				Name:      "myparam", // expected "myparam" because we don't allow integers to the parameter names.
-				Type:      ast.ParamTypeString,
+				Name:      "myparam2", // we now allow integers to the parameter names.
+				Type:      paramTypeString,
 				ErrorCode: 404,
 			},
 			}}, // 6
@@ -245,13 +315,13 @@ func TestParse(t *testing.T) {
 			[]ast.ParamStatement{{
 				Src:       "{file:path}",
 				Name:      "file",
-				Type:      ast.ParamTypePath,
+				Type:      paramTypePath,
 				ErrorCode: 404,
 			},
 			}}, // 7
 	}
 	for i, tt := range tests {
-		statements, err := Parse(tt.path)
+		statements, err := Parse(tt.path, testParamTypes)
 
 		if tt.valid && err != nil {
 			t.Fatalf("tests[%d] - error %s", i, err.Error())

macro/interpreter/token/token.go

@@ -13,7 +13,7 @@ type Token struct {
 
 // /about/{fullname:alphabetical}
 // /profile/{anySpecialName:string}
-// {id:int range(1,5) else 404}
+// {id:uint64 range(1,5) else 404}
 // /admin/{id:int eq(1) else 402}
 // /file/{filepath:file else 405}
 const (

macro/macro.go

@@ -0,0 +1,344 @@
+package macro
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+type (
+	// ParamEvaluator is the signature for param type evaluator.
+	// It accepts the param's value as string and returns
+	// the <T> value (which its type is used for the input argument of the parameter functions, if any)
+	// and a true value for passed, otherwise nil and false should be returned.
+	ParamEvaluator func(paramValue string) (interface{}, bool)
+)
+
+var goodEvaluatorFuncs = []reflect.Type{
+	reflect.TypeOf(func(string) (interface{}, bool) { return nil, false }),
+	reflect.TypeOf(ParamEvaluator(func(string) (interface{}, bool) { return nil, false })),
+}
+
+func goodParamFunc(typ reflect.Type) bool {
+	if typ.Kind() == reflect.Func { // it should be a func which returns a func (see below check).
+		if typ.NumOut() == 1 {
+			typOut := typ.Out(0)
+			if typOut.Kind() != reflect.Func {
+				return false
+			}
+
+			if typOut.NumOut() == 2 { // if it's a type of EvaluatorFunc, used for param evaluator.
+				for _, fType := range goodEvaluatorFuncs {
+					if typOut == fType {
+						return true
+					}
+				}
+				return false
+			}
+
+			if typOut.NumIn() == 1 && typOut.NumOut() == 1 { // if it's a type of func(paramValue [int,string...]) bool, used for param funcs.
+				return typOut.Out(0).Kind() == reflect.Bool
+			}
+		}
+	}
+
+	return false
+}
+
+// Regexp accepts a regexp "expr" expression
+// and returns its MatchString.
+// The regexp is compiled before return.
+//
+// Returns a not-nil error on regexp compile failure.
+func Regexp(expr string) (func(string) bool, error) {
+	if expr == "" {
+		return nil, fmt.Errorf("empty regex expression")
+	}
+
+	// add the last $ if missing (and not wildcard(?))
+	if i := expr[len(expr)-1]; i != '$' && i != '*' {
+		expr += "$"
+	}
+
+	r, err := regexp.Compile(expr)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.MatchString, nil
+}
+
+// MustRegexp same as Regexp
+// but it panics on the "expr" parse failure.
+func MustRegexp(expr string) func(string) bool {
+	r, err := Regexp(expr)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+// goodParamFuncName reports whether the function name is a valid identifier.
+func goodParamFuncName(name string) bool {
+	if name == "" {
+		return false
+	}
+	// valid names are only letters and _
+	for _, r := range name {
+		switch {
+		case r == '_':
+		case !unicode.IsLetter(r):
+			return false
+		}
+	}
+	return true
+}
+
+// the convertBuilderFunc return value is generating at boot time.
+// convertFunc converts an interface to a valid full param function.
+func convertBuilderFunc(fn interface{}) ParamFuncBuilder {
+
+	typFn := reflect.TypeOf(fn)
+	if !goodParamFunc(typFn) {
+		return nil
+	}
+
+	numFields := typFn.NumIn()
+
+	return func(args []string) reflect.Value {
+		if len(args) != numFields {
+			// no variadics support, for now.
+			panic("args should be the same len as numFields")
+		}
+		var argValues []reflect.Value
+		for i := 0; i < numFields; i++ {
+			field := typFn.In(i)
+			arg := args[i]
+
+			// try to convert the string literal as we get it from the parser.
+			var (
+				val interface{}
+
+				panicIfErr = func(err error) {
+					if err != nil {
+						panic(fmt.Sprintf("on field index: %d: %v", i, err))
+					}
+				}
+			)
+
+			// try to get the value based on the expected type.
+			switch field.Kind() {
+			case reflect.Int:
+				v, err := strconv.Atoi(arg)
+				panicIfErr(err)
+				val = v
+			case reflect.Int8:
+				v, err := strconv.ParseInt(arg, 10, 8)
+				panicIfErr(err)
+				val = int8(v)
+			case reflect.Int16:
+				v, err := strconv.ParseInt(arg, 10, 16)
+				panicIfErr(err)
+				val = int16(v)
+			case reflect.Int32:
+				v, err := strconv.ParseInt(arg, 10, 32)
+				panicIfErr(err)
+				val = int32(v)
+			case reflect.Int64:
+				v, err := strconv.ParseInt(arg, 10, 64)
+				panicIfErr(err)
+				val = v
+			case reflect.Uint:
+				v, err := strconv.ParseUint(arg, 10, strconv.IntSize)
+				panicIfErr(err)
+				val = uint(v)
+			case reflect.Uint8:
+				v, err := strconv.ParseUint(arg, 10, 8)
+				panicIfErr(err)
+				val = uint8(v)
+			case reflect.Uint16:
+				v, err := strconv.ParseUint(arg, 10, 16)
+				panicIfErr(err)
+				val = uint16(v)
+			case reflect.Uint32:
+				v, err := strconv.ParseUint(arg, 10, 32)
+				panicIfErr(err)
+				val = uint32(v)
+			case reflect.Uint64:
+				v, err := strconv.ParseUint(arg, 10, 64)
+				panicIfErr(err)
+				val = v
+			case reflect.Float32:
+				v, err := strconv.ParseFloat(arg, 32)
+				panicIfErr(err)
+				val = float32(v)
+			case reflect.Float64:
+				v, err := strconv.ParseFloat(arg, 64)
+				panicIfErr(err)
+				val = v
+			case reflect.Bool:
+				v, err := strconv.ParseBool(arg)
+				panicIfErr(err)
+				val = v
+			case reflect.Slice:
+				if len(arg) > 1 {
+					if arg[0] == '[' && arg[len(arg)-1] == ']' {
+						// it is a single argument but as slice.
+						val = strings.Split(arg[1:len(arg)-1], ",") // only string slices.
+					}
+				}
+
+			default:
+				val = arg
+			}
+
+			argValue := reflect.ValueOf(val)
+			if expected, got := field.Kind(), argValue.Kind(); expected != got {
+				panic(fmt.Sprintf("func's input arguments should have the same type: [%d] expected %s but got %s", i, expected, got))
+			}
+
+			argValues = append(argValues, argValue)
+		}
+
+		evalFn := reflect.ValueOf(fn).Call(argValues)[0]
+
+		// var evaluator EvaluatorFunc
+		// // check for typed and not typed
+		// if _v, ok := evalFn.(EvaluatorFunc); ok {
+		// 	evaluator = _v
+		// } else if _v, ok = evalFn.(func(string) bool); ok {
+		// 	evaluator = _v
+		// }
+		// return func(paramValue interface{}) bool {
+		// 	return evaluator(paramValue)
+		// }
+		return evalFn
+	}
+}
+
+type (
+	// Macro represents the parsed macro,
+	// which holds
+	// the evaluator (param type's evaluator + param functions evaluators)
+	// and its param functions.
+	//
+	// Any type contains its own macro
+	// instance, so an String type
+	// contains its type evaluator
+	// which is the "Evaluator" field
+	// and it can register param functions
+	// to that macro which maps to a parameter type.
+	Macro struct {
+		indent   string
+		alias    string
+		master   bool
+		trailing bool
+
+		Evaluator ParamEvaluator
+		funcs     []ParamFunc
+	}
+
+	// ParamFuncBuilder is a func
+	// which accepts a param function's arguments (values)
+	// and returns a function as value, its job
+	// is to make the macros to be registered
+	// by user at the most generic possible way.
+	ParamFuncBuilder func([]string) reflect.Value // the func(<T>) bool
+
+	// ParamFunc represents the parsed
+	// parameter function, it holds
+	// the parameter's name
+	// and the function which will build
+	// the evaluator func.
+	ParamFunc struct {
+		Name string
+		Func ParamFuncBuilder
+	}
+)
+
+// NewMacro creates and returns a Macro that can be used as a registry for
+// a new customized parameter type and its functions.
+func NewMacro(indent, alias string, master, trailing bool, evaluator ParamEvaluator) *Macro {
+	return &Macro{
+		indent:   indent,
+		alias:    alias,
+		master:   master,
+		trailing: trailing,
+
+		Evaluator: evaluator,
+	}
+}
+
+// Indent returns the name of the parameter type.
+func (m *Macro) Indent() string {
+	return m.indent
+}
+
+// Alias returns the alias of the parameter type, if any.
+func (m *Macro) Alias() string {
+	return m.alias
+}
+
+// Master returns true if that macro's parameter type is the
+// default one if not :type is followed by a parameter type inside the route path.
+func (m *Macro) Master() bool {
+	return m.master
+}
+
+// Trailing returns true if that macro's parameter type
+// is wildcard and can accept one or more path segments as one parameter value.
+// A wildcard should be registered in the last path segment only.
+func (m *Macro) Trailing() bool {
+	return m.trailing
+}
+
+// func (m *Macro) SetParamResolver(fn func(memstore.Entry) interface{}) *Macro {
+// 	m.ParamResolver = fn
+// 	return m
+// }
+
+// RegisterFunc registers a parameter function
+// to that macro.
+// Accepts the func name ("range")
+// and the function body, which should return an EvaluatorFunc
+// a bool (it will be converted to EvaluatorFunc later on),
+// i.e RegisterFunc("min", func(minValue int) func(paramValue string) bool){})
+func (m *Macro) RegisterFunc(funcName string, fn interface{}) *Macro {
+	fullFn := convertBuilderFunc(fn)
+	m.registerFunc(funcName, fullFn)
+
+	return m
+}
+
+func (m *Macro) registerFunc(funcName string, fullFn ParamFuncBuilder) {
+	if !goodParamFuncName(funcName) {
+		return
+	}
+
+	for _, fn := range m.funcs {
+		if fn.Name == funcName {
+			fn.Func = fullFn
+			return
+		}
+	}
+
+	m.funcs = append(m.funcs, ParamFunc{
+		Name: funcName,
+		Func: fullFn,
+	})
+}
+
+func (m *Macro) getFunc(funcName string) ParamFuncBuilder {
+	for _, fn := range m.funcs {
+		if fn.Name == funcName {
+			if fn.Func == nil {
+				continue
+			}
+			return fn.Func
+		}
+	}
+	return nil
+}

macro/macro_test.go

@@ -0,0 +1,453 @@
+package macro
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+// Most important tests to look:
+// ../parser/parser_test.go
+// ../lexer/lexer_test.go
+
+func TestGoodParamFunc(t *testing.T) {
+	good1 := func(min int, max int) func(string) bool {
+		return func(paramValue string) bool {
+			return true
+		}
+	}
+
+	good2 := func(min uint64, max uint64) func(string) bool {
+		return func(paramValue string) bool {
+			return true
+		}
+	}
+
+	notgood1 := func(min int, max int) bool {
+		return false
+	}
+
+	if !goodParamFunc(reflect.TypeOf(good1)) {
+		t.Fatalf("expected good1 func to be good but it's not")
+	}
+
+	if !goodParamFunc(reflect.TypeOf(good2)) {
+		t.Fatalf("expected good2 func to be good but it's not")
+	}
+
+	if goodParamFunc(reflect.TypeOf(notgood1)) {
+		t.Fatalf("expected notgood1 func to be the worst")
+	}
+}
+
+func TestGoodParamFuncName(t *testing.T) {
+	tests := []struct {
+		name string
+		good bool
+	}{
+		{"range", true},
+		{"_range", true},
+		{"range_", true},
+		{"r_ange", true},
+		// numbers or other symbols are invalid.
+		{"range1", false},
+		{"2range", false},
+		{"r@nge", false},
+		{"rang3", false},
+	}
+	for i, tt := range tests {
+		isGood := goodParamFuncName(tt.name)
+		if tt.good && !isGood {
+			t.Fatalf("tests[%d] - expecting valid name but got invalid for name %s", i, tt.name)
+		} else if !tt.good && isGood {
+			t.Fatalf("tests[%d] - expecting invalid name but got valid for name %s", i, tt.name)
+		}
+	}
+}
+
+func testEvaluatorRaw(t *testing.T, macroEvaluator *Macro, input string, expectedType reflect.Kind, pass bool, i int) {
+	if macroEvaluator.Evaluator == nil && pass {
+		return // if not evaluator defined then it should allow everything.
+	}
+	value, passed := macroEvaluator.Evaluator(input)
+	if pass != passed {
+		t.Fatalf("%s - tests[%d] - expecting[pass] %v but got %v", t.Name(), i, pass, passed)
+	}
+
+	if !passed {
+		return
+	}
+
+	if value == nil && expectedType != reflect.Invalid {
+		t.Fatalf("%s - tests[%d] - expecting[value] to not be nil", t.Name(), i)
+	}
+
+	if v := reflect.ValueOf(value); v.Kind() != expectedType {
+		t.Fatalf("%s - tests[%d] - expecting[value.Kind] %v but got %v", t.Name(), i, expectedType, v.Kind())
+	}
+}
+
+func TestStringEvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                         // 0
+		{true, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                           // 2
+		{true, "main.css"},                        // 3
+		{true, "/assets/main.css"},                // 4
+		// false never
+	} // 0
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, String, tt.input, reflect.String, tt.pass, i)
+	}
+}
+
+func TestIntEvaluatorRaw(t *testing.T) {
+	x64 := strconv.IntSize == 64
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                                 // 0
+		{false, "astringwith_numb3rS_and_symbol$"},         // 1
+		{true, "32321"},                                    // 2
+		{x64, "9223372036854775807" /* max int64 */},       // 3
+		{x64, "-9223372036854775808" /* min int64 */},      // 4
+		{false, "-18446744073709553213213213213213121615"}, // 5
+		{false, "42 18446744073709551615"},                 // 6
+		{false, "--42"},                                    // 7
+		{false, "+42"},                                     // 8
+		{false, "main.css"},                                // 9
+		{false, "/assets/main.css"},                        // 10
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Int, tt.input, reflect.Int, tt.pass, i)
+	}
+}
+
+func TestInt8EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{false, "32321"},                           // 2
+		{true, "127" /* max int8 */},               // 3
+		{true, "-128" /* min int8 */},              // 4
+		{false, "128"},                             // 5
+		{false, "-129"},                            // 6
+		{false, "-18446744073709553213213213213213121615"}, // 7
+		{false, "42 18446744073709551615"},                 // 8
+		{false, "--42"},                                    // 9
+		{false, "+42"},                                     // 10
+		{false, "main.css"},                                // 11
+		{false, "/assets/main.css"},                        // 12
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Int8, tt.input, reflect.Int8, tt.pass, i)
+	}
+}
+
+func TestInt16EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "32767" /* max int16 */},            // 3
+		{true, "-32768" /* min int16 */},           // 4
+		{false, "-32769"},                          // 5
+		{false, "32768"},                           // 6
+		{false, "-18446744073709553213213213213213121615"}, // 7
+		{false, "42 18446744073709551615"},                 // 8
+		{false, "--42"},                                    // 9
+		{false, "+42"},                                     // 10
+		{false, "main.css"},                                // 11
+		{false, "/assets/main.css"},                        // 12
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Int16, tt.input, reflect.Int16, tt.pass, i)
+	}
+}
+
+func TestInt32EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "1"},                                // 3
+		{true, "42"},                               // 4
+		{true, "2147483647" /* max int32 */},       // 5
+		{true, "-2147483648" /* min int32 */},      // 6
+		{false, "-2147483649"},                     // 7
+		{false, "2147483648"},                      // 8
+		{false, "-18446744073709553213213213213213121615"}, // 9
+		{false, "42 18446744073709551615"},                 // 10
+		{false, "--42"},                                    // 11
+		{false, "+42"},                                     // 12
+		{false, "main.css"},                                // 13
+		{false, "/assets/main.css"},                        // 14
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Int32, tt.input, reflect.Int32, tt.pass, i)
+	}
+}
+
+func TestInt64EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                                 // 0
+		{false, "astringwith_numb3rS_and_symbol$"},         // 1
+		{false, "18446744073709551615"},                    // 2
+		{false, "92233720368547758079223372036854775807"},  // 3
+		{false, "9223372036854775808 9223372036854775808"}, // 4
+		{false, "main.css"},                                // 5
+		{false, "/assets/main.css"},                        // 6
+		{true, "9223372036854775807"},                      // 7
+		{true, "-9223372036854775808"},                     // 8
+		{true, "-0"},                                       // 9
+		{true, "1"},                                        // 10
+		{true, "-042"},                                     // 11
+		{true, "142"},                                      // 12
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Int64, tt.input, reflect.Int64, tt.pass, i)
+	}
+}
+
+func TestUintEvaluatorRaw(t *testing.T) {
+	x64 := strconv.IntSize == 64
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                             // 0
+		{false, "astringwith_numb3rS_and_symbol$"},     // 1
+		{true, "32321"},                                // 2
+		{true, "1"},                                    // 3
+		{true, "42"},                                   // 4
+		{x64, "18446744073709551615" /* max uint64 */}, // 5
+		{true, "4294967295" /* max uint32 */},          // 6
+		{false, "-2147483649"},                         // 7
+		{true, "2147483648"},                           // 8
+		{false, "-18446744073709553213213213213213121615"}, // 9
+		{false, "42 18446744073709551615"},                 // 10
+		{false, "--42"},                                    // 11
+		{false, "+42"},                                     // 12
+		{false, "main.css"},                                // 13
+		{false, "/assets/main.css"},                        // 14
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Uint, tt.input, reflect.Uint, tt.pass, i)
+	}
+}
+
+func TestUint8EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                                 // 0
+		{false, "astringwith_numb3rS_and_symbol$"},         // 1
+		{false, "-9223372036854775808"},                    // 2
+		{false, "main.css"},                                // 3
+		{false, "/assets/main.css"},                        // 4
+		{false, "92233720368547758079223372036854775807"},  // 5
+		{false, "9223372036854775808 9223372036854775808"}, // 6
+		{false, "-1"},                                      // 7
+		{false, "-0"},                                      // 8
+		{false, "+1"},                                      // 9
+		{false, "18446744073709551615"},                    // 10
+		{false, "9223372036854775807"},                     // 11
+		{false, "021"},                                     // 12 - no leading zeroes are allowed.
+		{false, "300"},                                     // 13
+		{true, "0"},                                        // 14
+		{true, "255"},                                      // 15
+		{true, "21"},                                       // 16
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Uint8, tt.input, reflect.Uint8, tt.pass, i)
+	}
+}
+
+func TestUint16EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "65535" /* max uint16 */},           // 3
+		{true, "0" /* min uint16 */},               // 4
+		{false, "-32769"},                          // 5
+		{true, "32768"},                            // 6
+		{false, "-18446744073709553213213213213213121615"}, // 7
+		{false, "42 18446744073709551615"},                 // 8
+		{false, "--42"},                                    // 9
+		{false, "+42"},                                     // 10
+		{false, "main.css"},                                // 11
+		{false, "/assets/main.css"},                        // 12
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Uint16, tt.input, reflect.Uint16, tt.pass, i)
+	}
+}
+
+func TestUint32EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "1"},                                // 3
+		{true, "42"},                               // 4
+		{true, "4294967295" /* max uint32*/},       // 5
+		{true, "0" /* min uint32 */},               // 6
+		{false, "-2147483649"},                     // 7
+		{true, "2147483648"},                       // 8
+		{false, "-18446744073709553213213213213213121615"}, // 9
+		{false, "42 18446744073709551615"},                 // 10
+		{false, "--42"},                                    // 11
+		{false, "+42"},                                     // 12
+		{false, "main.css"},                                // 13
+		{false, "/assets/main.css"},                        // 14
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Uint32, tt.input, reflect.Uint32, tt.pass, i)
+	}
+}
+
+func TestUint64EvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                                 // 0
+		{false, "astringwith_numb3rS_and_symbol$"},         // 1
+		{false, "-9223372036854775808"},                    // 2
+		{false, "main.css"},                                // 3
+		{false, "/assets/main.css"},                        // 4
+		{false, "92233720368547758079223372036854775807"},  // 5
+		{false, "9223372036854775808 9223372036854775808"}, // 6
+		{false, "-1"},                                      // 7
+		{false, "-0"},                                      // 8
+		{false, "+1"},                                      // 9
+		{true, "18446744073709551615"},                     // 10
+		{true, "9223372036854775807"},                      // 11
+		{true, "0"},                                        // 12
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Uint64, tt.input, reflect.Uint64, tt.pass, i)
+	}
+}
+
+func TestAlphabeticalEvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                          // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{false, "32321"},                           // 2
+		{false, "main.css"},                        // 3
+		{false, "/assets/main.css"},                // 4
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, Alphabetical, tt.input, reflect.String, tt.pass, i)
+	}
+}
+
+func TestFileEvaluatorRaw(t *testing.T) {
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                          // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "main.css"},                         // 3
+		{false, "/assets/main.css"},                // 4
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(t, File, tt.input, reflect.String, tt.pass, i)
+	}
+}
+
+func TestPathEvaluatorRaw(t *testing.T) {
+	pathTests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                         // 0
+		{true, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                           // 2
+		{true, "main.css"},                        // 3
+		{true, "/assets/main.css"},                // 4
+		{true, "disk/assets/main.css"},            // 5
+	}
+
+	for i, tt := range pathTests {
+		testEvaluatorRaw(t, Path, tt.input, reflect.String, tt.pass, i)
+	}
+}
+
+func TestConvertBuilderFunc(t *testing.T) {
+	fn := func(min uint64, slice []string) func(string) bool {
+		return func(paramValue string) bool {
+			if expected, got := "ok", paramValue; expected != got {
+				t.Fatalf("paramValue is not the expected one: %s vs %s", expected, got)
+			}
+
+			if expected, got := uint64(1), min; expected != got {
+				t.Fatalf("min argument is not the expected one: %d vs %d", expected, got)
+			}
+
+			if expected, got := []string{"name1", "name2"}, slice; len(expected) == len(got) {
+				if expected, got := "name1", slice[0]; expected != got {
+					t.Fatalf("slice argument[%d] does not contain the expected value: %s vs %s", 0, expected, got)
+				}
+
+				if expected, got := "name2", slice[1]; expected != got {
+					t.Fatalf("slice argument[%d] does not contain the expected value: %s vs %s", 1, expected, got)
+				}
+			} else {
+				t.Fatalf("slice argument is not the expected one, the length is difference: %d vs %d", len(expected), len(got))
+			}
+
+			return true
+		}
+	}
+
+	evalFunc := convertBuilderFunc(fn)
+	if !evalFunc([]string{"1", "[name1,name2]"}).Call([]reflect.Value{reflect.ValueOf("ok")})[0].Interface().(bool) {
+		t.Fatalf("failed, it should fail already")
+	}
+}

macro/macros.go

@@ -0,0 +1,550 @@
+package macro
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/kataras/iris/macro/interpreter/ast"
+)
+
+var (
+	// String type
+	// Allows anything (single path segment, as everything except the `Path`).
+	// Its functions can be used by the rest of the macros and param types whenever not available function by name is used.
+	// Because of its "master" boolean value to true (third parameter).
+	String = NewMacro("string", "", true, false, nil).
+		RegisterFunc("regexp", MustRegexp).
+		// checks if param value starts with the 'prefix' arg
+		RegisterFunc("prefix", func(prefix string) func(string) bool {
+			return func(paramValue string) bool {
+				return strings.HasPrefix(paramValue, prefix)
+			}
+		}).
+		// checks if param value ends with the 'suffix' arg
+		RegisterFunc("suffix", func(suffix string) func(string) bool {
+			return func(paramValue string) bool {
+				return strings.HasSuffix(paramValue, suffix)
+			}
+		}).
+		// checks if param value contains the 's' arg
+		RegisterFunc("contains", func(s string) func(string) bool {
+			return func(paramValue string) bool {
+				return strings.Contains(paramValue, s)
+			}
+		}).
+		// checks if param value's length is at least 'min'
+		RegisterFunc("min", func(min int) func(string) bool {
+			return func(paramValue string) bool {
+				return len(paramValue) >= min
+			}
+		}).
+		// checks if param value's length is not bigger than 'max'
+		RegisterFunc("max", func(max int) func(string) bool {
+			return func(paramValue string) bool {
+				return max >= len(paramValue)
+			}
+		})
+
+	simpleNumberEval = MustRegexp("^-?[0-9]+$")
+	// Int or number type
+	// both positive and negative numbers, actual value can be min-max int64 or min-max int32 depends on the arch.
+	// If x64: -9223372036854775808 to 9223372036854775807.
+	// If x32: -2147483648 to 2147483647 and etc..
+	Int = NewMacro("int", "number", false, false, func(paramValue string) (interface{}, bool) {
+		if !simpleNumberEval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.Atoi(paramValue)
+		if err != nil {
+			return nil, false
+		}
+
+		return v, true
+	}).
+		// checks if the param value's int representation is
+		// bigger or equal than 'min'
+		RegisterFunc("min", func(min int) func(int) bool {
+			return func(paramValue int) bool {
+				return paramValue >= min
+			}
+		}).
+		// checks if the param value's int representation is
+		// smaller or equal than 'max'.
+		RegisterFunc("max", func(max int) func(int) bool {
+			return func(paramValue int) bool {
+				return paramValue <= max
+			}
+		}).
+		// checks if the param value's int representation is
+		// between min and max, including 'min' and 'max'.
+		RegisterFunc("range", func(min, max int) func(int) bool {
+			return func(paramValue int) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Int8 type
+	// -128 to 127.
+	Int8 = NewMacro("int8", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !simpleNumberEval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.ParseInt(paramValue, 10, 8)
+		if err != nil {
+			return nil, false
+		}
+		return int8(v), true
+	}).
+		RegisterFunc("min", func(min int8) func(int8) bool {
+			return func(paramValue int8) bool {
+				return paramValue >= min
+			}
+		}).
+		RegisterFunc("max", func(max int8) func(int8) bool {
+			return func(paramValue int8) bool {
+				return paramValue <= max
+			}
+		}).
+		RegisterFunc("range", func(min, max int8) func(int8) bool {
+			return func(paramValue int8) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Int16 type
+	// -32768 to 32767.
+	Int16 = NewMacro("int16", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !simpleNumberEval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.ParseInt(paramValue, 10, 16)
+		if err != nil {
+			return nil, false
+		}
+		return int16(v), true
+	}).
+		RegisterFunc("min", func(min int16) func(int16) bool {
+			return func(paramValue int16) bool {
+				return paramValue >= min
+			}
+		}).
+		RegisterFunc("max", func(max int16) func(int16) bool {
+			return func(paramValue int16) bool {
+				return paramValue <= max
+			}
+		}).
+		RegisterFunc("range", func(min, max int16) func(int16) bool {
+			return func(paramValue int16) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Int32 type
+	// -2147483648 to 2147483647.
+	Int32 = NewMacro("int32", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !simpleNumberEval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.ParseInt(paramValue, 10, 32)
+		if err != nil {
+			return nil, false
+		}
+		return int32(v), true
+	}).
+		RegisterFunc("min", func(min int32) func(int32) bool {
+			return func(paramValue int32) bool {
+				return paramValue >= min
+			}
+		}).
+		RegisterFunc("max", func(max int32) func(int32) bool {
+			return func(paramValue int32) bool {
+				return paramValue <= max
+			}
+		}).
+		RegisterFunc("range", func(min, max int32) func(int32) bool {
+			return func(paramValue int32) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Int64 as int64 type
+	// -9223372036854775808 to 9223372036854775807.
+	Int64 = NewMacro("int64", "long", false, false, func(paramValue string) (interface{}, bool) {
+		if !simpleNumberEval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.ParseInt(paramValue, 10, 64)
+		if err != nil { // if err == strconv.ErrRange...
+			return nil, false
+		}
+		return v, true
+	}).
+		// checks if the param value's int64 representation is
+		// bigger or equal than 'min'.
+		RegisterFunc("min", func(min int64) func(int64) bool {
+			return func(paramValue int64) bool {
+				return paramValue >= min
+			}
+		}).
+		// checks if the param value's int64 representation is
+		// smaller or equal than 'max'.
+		RegisterFunc("max", func(max int64) func(int64) bool {
+			return func(paramValue int64) bool {
+				return paramValue <= max
+			}
+		}).
+		// checks if the param value's int64 representation is
+		// between min and max, including 'min' and 'max'.
+		RegisterFunc("range", func(min, max int64) func(int64) bool {
+			return func(paramValue int64) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Uint as uint type
+	// actual value can be min-max uint64 or min-max uint32 depends on the arch.
+	// If x64: 0 to 18446744073709551615.
+	// If x32: 0 to 4294967295 and etc.
+	Uint = NewMacro("uint", "", false, false, func(paramValue string) (interface{}, bool) {
+		v, err := strconv.ParseUint(paramValue, 10, strconv.IntSize) // 32,64...
+		if err != nil {
+			return nil, false
+		}
+		return uint(v), true
+	}).
+		// checks if the param value's int representation is
+		// bigger or equal than 'min'
+		RegisterFunc("min", func(min uint) func(uint) bool {
+			return func(paramValue uint) bool {
+				return paramValue >= min
+			}
+		}).
+		// checks if the param value's int representation is
+		// smaller or equal than 'max'.
+		RegisterFunc("max", func(max uint) func(uint) bool {
+			return func(paramValue uint) bool {
+				return paramValue <= max
+			}
+		}).
+		// checks if the param value's int representation is
+		// between min and max, including 'min' and 'max'.
+		RegisterFunc("range", func(min, max uint) func(uint) bool {
+			return func(paramValue uint) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	uint8Eval = MustRegexp("^([0-9]|[1-8][0-9]|9[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$")
+	// Uint8 as uint8 type
+	// 0 to 255.
+	Uint8 = NewMacro("uint8", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !uint8Eval(paramValue) {
+			return nil, false
+		}
+
+		v, err := strconv.ParseUint(paramValue, 10, 8)
+		if err != nil {
+			return nil, false
+		}
+		return uint8(v), true
+	}).
+		// checks if the param value's uint8 representation is
+		// bigger or equal than 'min'.
+		RegisterFunc("min", func(min uint8) func(uint8) bool {
+			return func(paramValue uint8) bool {
+				return paramValue >= min
+			}
+		}).
+		// checks if the param value's uint8 representation is
+		// smaller or equal than 'max'.
+		RegisterFunc("max", func(max uint8) func(uint8) bool {
+			return func(paramValue uint8) bool {
+				return paramValue <= max
+			}
+		}).
+		// checks if the param value's uint8 representation is
+		// between min and max, including 'min' and 'max'.
+		RegisterFunc("range", func(min, max uint8) func(uint8) bool {
+			return func(paramValue uint8) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Uint16 as uint16 type
+	// 0 to 65535.
+	Uint16 = NewMacro("uint16", "", false, false, func(paramValue string) (interface{}, bool) {
+		v, err := strconv.ParseUint(paramValue, 10, 16)
+		if err != nil {
+			return nil, false
+		}
+		return uint16(v), true
+	}).
+		RegisterFunc("min", func(min uint16) func(uint16) bool {
+			return func(paramValue uint16) bool {
+				return paramValue >= min
+			}
+		}).
+		RegisterFunc("max", func(max uint16) func(uint16) bool {
+			return func(paramValue uint16) bool {
+				return paramValue <= max
+			}
+		}).
+		RegisterFunc("range", func(min, max uint16) func(uint16) bool {
+			return func(paramValue uint16) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Uint32 as uint32 type
+	// 0 to 4294967295.
+	Uint32 = NewMacro("uint32", "", false, false, func(paramValue string) (interface{}, bool) {
+		v, err := strconv.ParseUint(paramValue, 10, 32)
+		if err != nil {
+			return nil, false
+		}
+		return uint32(v), true
+	}).
+		RegisterFunc("min", func(min uint32) func(uint32) bool {
+			return func(paramValue uint32) bool {
+				return paramValue >= min
+			}
+		}).
+		RegisterFunc("max", func(max uint32) func(uint32) bool {
+			return func(paramValue uint32) bool {
+				return paramValue <= max
+			}
+		}).
+		RegisterFunc("range", func(min, max uint32) func(uint32) bool {
+			return func(paramValue uint32) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Uint64 as uint64 type
+	// 0 to 18446744073709551615.
+	Uint64 = NewMacro("uint64", "", false, false, func(paramValue string) (interface{}, bool) {
+		v, err := strconv.ParseUint(paramValue, 10, 64)
+		if err != nil {
+			return nil, false
+		}
+		return v, true
+	}).
+		// checks if the param value's uint64 representation is
+		// bigger or equal than 'min'.
+		RegisterFunc("min", func(min uint64) func(uint64) bool {
+			return func(paramValue uint64) bool {
+				return paramValue >= min
+			}
+		}).
+		// checks if the param value's uint64 representation is
+		// smaller or equal than 'max'.
+		RegisterFunc("max", func(max uint64) func(uint64) bool {
+			return func(paramValue uint64) bool {
+				return paramValue <= max
+			}
+		}).
+		// checks if the param value's uint64 representation is
+		// between min and max, including 'min' and 'max'.
+		RegisterFunc("range", func(min, max uint64) func(uint64) bool {
+			return func(paramValue uint64) bool {
+				return !(paramValue < min || paramValue > max)
+			}
+		})
+
+	// Bool or boolean as bool type
+	// a string which is "1" or "t" or "T" or "TRUE" or "true" or "True"
+	// or "0" or "f" or "F" or "FALSE" or "false" or "False".
+	Bool = NewMacro("bool", "boolean", false, false, func(paramValue string) (interface{}, bool) {
+		// a simple if statement is faster than regex ^(true|false|True|False|t|0|f|FALSE|TRUE)$
+		// in this case.
+		v, err := strconv.ParseBool(paramValue)
+		if err != nil {
+			return nil, false
+		}
+		return v, true
+	})
+
+	alphabeticalEval = MustRegexp("^[a-zA-Z ]+$")
+	// Alphabetical letter type
+	// letters only (upper or lowercase)
+	Alphabetical = NewMacro("alphabetical", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !alphabeticalEval(paramValue) {
+			return nil, false
+		}
+		return paramValue, true
+	})
+
+	fileEval = MustRegexp("^[a-zA-Z0-9_.-]*$")
+	// File type
+	// letters (upper or lowercase)
+	// numbers (0-9)
+	// underscore (_)
+	// dash (-)
+	// point (.)
+	// no spaces! or other character
+	File = NewMacro("file", "", false, false, func(paramValue string) (interface{}, bool) {
+		if !fileEval(paramValue) {
+			return nil, false
+		}
+		return paramValue, true
+	})
+	// Path type
+	// anything, should be the last part
+	//
+	// It allows everything, we have String and Path as different
+	// types because I want to give the opportunity to the user
+	// to organise the macro functions based on wildcard or single dynamic named path parameter.
+	// Should be living in the latest path segment of a route path.
+	Path = NewMacro("path", "", false, true, nil)
+
+	// Defaults contains the defaults macro and parameters types for the router.
+	//
+	// Read https://github.com/kataras/iris/tree/master/_examples/routing/macros for more details.
+	Defaults = &Macros{
+		String,
+		Int,
+		Int8,
+		Int16,
+		Int32,
+		Int64,
+		Uint,
+		Uint8,
+		Uint16,
+		Uint32,
+		Uint64,
+		Bool,
+		Alphabetical,
+		Path,
+	}
+)
+
+// Macros is just a type of a slice of *Macro
+// which is responsible to register and search for macros based on the indent(parameter type).
+type Macros []*Macro
+
+// Register registers a custom Macro.
+// The "indent" should not be empty and should be unique, it is the parameter type's name, i.e "string".
+// The "alias" is optionally and it should be unique, it is the alias of the parameter type.
+// "isMaster" and "isTrailing" is for default parameter type and wildcard respectfully.
+// The "evaluator" is the function that is converted to an Iris handler which is executed every time
+// before the main chain of a route's handlers that contains this macro of the specific parameter type.
+//
+// Read https://github.com/kataras/iris/tree/master/_examples/routing/macros for more details.
+func (ms *Macros) Register(indent, alias string, isMaster, isTrailing bool, evaluator ParamEvaluator) *Macro {
+	macro := NewMacro(indent, alias, isMaster, isTrailing, evaluator)
+	if ms.register(macro) {
+		return macro
+	}
+	return nil
+}
+
+func (ms *Macros) register(macro *Macro) bool {
+	if macro.Indent() == "" {
+		return false
+	}
+
+	cp := *ms
+
+	for _, m := range cp {
+		// can't add more than one with the same ast characteristics.
+		if macro.Indent() == m.Indent() {
+			return false
+		}
+
+		if alias := macro.Alias(); alias != "" {
+			if alias == m.Alias() || alias == m.Indent() {
+				return false
+			}
+		}
+
+		if macro.Master() && m.Master() {
+			return false
+		}
+	}
+
+	cp = append(cp, macro)
+
+	*ms = cp
+	return true
+}
+
+// Unregister removes a macro and its parameter type from the list.
+func (ms *Macros) Unregister(indent string) bool {
+	cp := *ms
+
+	for i, m := range cp {
+		if m.Indent() == indent {
+			copy(cp[i:], cp[i+1:])
+			cp[len(cp)-1] = nil
+			cp = cp[:len(cp)-1]
+
+			*ms = cp
+			return true
+		}
+	}
+
+	return false
+}
+
+// Lookup returns the responsible macro for a parameter type, it can return nil.
+func (ms *Macros) Lookup(pt ast.ParamType) *Macro {
+	if m := ms.Get(pt.Indent()); m != nil {
+		return m
+	}
+
+	if alias, has := ast.HasAlias(pt); has {
+		if m := ms.Get(alias); m != nil {
+			return m
+		}
+	}
+
+	return nil
+}
+
+// Get returns the responsible macro for a parameter type, it can return nil.
+func (ms *Macros) Get(indentOrAlias string) *Macro {
+	if indentOrAlias == "" {
+		return nil
+	}
+
+	for _, m := range *ms {
+		if m.Indent() == indentOrAlias {
+			return m
+		}
+
+		if m.Alias() == indentOrAlias {
+			return m
+		}
+	}
+
+	return nil
+}
+
+// GetMaster returns the default macro and its parameter type,
+// by default it will return the `String` macro which is responsible for the "string" parameter type.
+func (ms *Macros) GetMaster() *Macro {
+	for _, m := range *ms {
+		if m.Master() {
+			return m
+		}
+	}
+
+	return nil
+}
+
+// GetTrailings returns the macros that have support for wildcards parameter types.
+// By default it will return the `Path` macro which is responsible for the "path" parameter type.
+func (ms *Macros) GetTrailings() (macros []*Macro) {
+	for _, m := range *ms {
+		if m.Trailing() {
+			macros = append(macros, m)
+		}
+	}
+
+	return
+}