feat(Go-Tool)：2020/12/14:添加validator.v8源码解析和使用示例

vendor/github.com/ahmetb/go-linq/README.md

@@ -1,21 +1,16 @@
 # go-linq [![GoDoc](https://godoc.org/github.com/ahmetalpbalkan/go-linq?status.svg)](https://godoc.org/github.com/ahmetalpbalkan/go-linq) [![Build Status](https://travis-ci.org/ahmetalpbalkan/go-linq.svg?branch=master)](https://travis-ci.org/ahmetalpbalkan/go-linq) [![Coverage Status](https://coveralls.io/repos/github/ahmetalpbalkan/go-linq/badge.svg?branch=master)](https://coveralls.io/github/ahmetalpbalkan/go-linq?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/ahmetalpbalkan/go-linq)](https://goreportcard.com/report/github.com/ahmetalpbalkan/go-linq)
 A powerful language integrated query (LINQ) library for Go.
-* Written in vanilla Go, no dependencies!
-* Complete lazy evaluation with iterator pattern
+* Written in vanilla Go!
 * Safe for concurrent use
-* Supports generic functions to make your code cleaner and free of type assertions
+* Complete lazy evaluation with iterator pattern
 * Supports arrays, slices, maps, strings, channels and custom collections
+(collection needs to implement `Iterable` interface and element - `Comparable`
+interface)
 
 ## Installation
 
     $ go get github.com/ahmetalpbalkan/go-linq
 
-We recommend using a dependency manager (e.g. [govendor][govendor] or
-[godep][godep]) to maintain a local copy of this package in your project.
-
-[govendor]: https://github.com/kardianos/govendor
-[godep]: https://github.com/tools/godep/
-
 > :warning: :warning: `go-linq` has recently introduced _breaking API changes_
 > with v2.0.0. See [release notes](#release-notes) for details. v2.0.0 comes with
 > a refined interface, dramatically increased performance and memory efficiency,
@@ -31,20 +26,16 @@ Usage is as easy as chaining methods like:
 
 `From(slice)` `.Where(predicate)` `.Select(selector)` `.Union(data)` 
 
-**Example 1: Find all owners of cars manufactured after 2015**
-
+**Example: Find all owners of cars manufactured from 2015**
 ```go
 import . "github.com/ahmetalpbalkan/go-linq"
 	
 type Car struct {
-    year int
+    id, year int
     owner, model string
 }
 
-...
-
-
-var owners []string
+owners := []string{}
 
 From(cars).Where(func(c interface{}) bool {
 	return c.(Car).year >= 2015
@@ -53,21 +44,7 @@ From(cars).Where(func(c interface{}) bool {
 }).ToSlice(&owners)
 ```
 
-Or, you can use generic functions, like `WhereT` and `SelectT` to simplify your code
-(at a performance penalty):
-
-```go
-var owners []string
-
-From(cars).WhereT(func(c Car) bool {
-	return c.year >= 2015
-}).SelectT(func(c Car) string {
-	return c.owner
-}).ToSlice(&owners)	
-```
-
-**Example 2: Find the author who has written the most books**
-
+**Example: Find the author who has written the most books**
 ```go
 import . "github.com/ahmetalpbalkan/go-linq"
 	
@@ -94,8 +71,7 @@ author := From(books).SelectMany( // make a flat array of authors
 	}).First() // take the first author
 ```
 
-**Example 3: Implement a custom method that leaves only values greater than the specified threshold**
-
+**Example: Implement a custom method that leaves only values greater than the specified threshold**
 ```go
 type MyQuery Query
 
@@ -120,67 +96,10 @@ func (q MyQuery) GreaterThan(threshold int) Query {
 result := MyQuery(Range(1,10)).GreaterThan(5).Results()
 ```
 
-## Generic Functions
-
-Although Go doesn't implement generics, with some reflection tricks, you can use go-linq without
-typing `interface{}`s and type assertions. This will introduce a performance penalty (5x-10x slower)
-but will yield in a cleaner and more readable code.
-
-Methods with `T` suffix (such as `WhereT`) accept functions with generic types. So instead of
-
-    .Select(func(v interface{}) interface{} {...})
-
-you can type:
-
-    .SelectT(func(v YourType) YourOtherType {...})
-
-This will make your code free of `interface{}` and type assertions.
-
-**Example 4: "MapReduce" in a slice of string sentences to list the top 5 most used words using generic functions**
-
-```go
-var results []string
-
-From(sentences).
-	// split sentences to words
-	SelectManyT(func(sentence string) Query {
-		return From(strings.Split(sentence, " "))
-	}).
-	// group the words
-	GroupByT( 
-		func(word string) string { return word },
-		func(word string) string { return word },
-	).
-	// order by count
-	OrderByDescendingT(func(wordGroup Group) int {
-		return len(wordGroup.Group)
-	}).
-	// order by the word
-	ThenByT(func(wordGroup Group) string {
-		return wordGroup.Key.(string)
-	}).
-	Take(5).  // take the top 5
-	// project the words using the index as rank
-	SelectIndexedT(func(index int, wordGroup Group) string {
-		return fmt.Sprintf("Rank: #%d, Word: %s, Counts: %d", index+1, wordGroup.Key, len(wordGroup.Group))
-	}).
-	ToSlice(&results)
-```
-
-**More examples** can be found in the [documentation](https://godoc.org/github.com/ahmetalpbalkan/go-linq).
+**More examples** can be found in [documentation](https://godoc.org/github.com/ahmetalpbalkan/go-linq).
 
 ## Release Notes
-
 ~~~
-v3.0.0 (2017-01-10)
-* Breaking change: ToSlice() now overwrites existing slice starting
-  from index 0 and grows/reslices it as needed.
-* Generic methods support (thanks @cleitonmarx!)
-  - Accepting parametrized functions was originally proposed in #26
-  - You can now avoid type assertions and interface{}s
-  - Functions with generic methods are named as "MethodNameT" and
-    signature for the existing LINQ methods are unchanged.
-* Added ForEach(), ForEachIndexed() and AggregateWithSeedBy().
 
 v2.0.0 (2016-09-02)
 * IMPORTANT: This release is a BREAKING CHANGE. The old version