diff --git a/README.md b/README.md
index eb6ec6a..6af89aa 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ let query = Queryable
                     total: Queryable.fromSync(x.items).count() // Here will return number, not Promise<number>
                 }
             })
-const asyncData = query.count() // Will return Promise<{area:string, total:number}>
+const asyncData = query.toList() // Will return Promise<{area:string, total:number}>
 asyncData.then(data => {
     console.log(data);
     // [
diff --git a/src/demo/test.ts b/src/demo/test.ts
index 6ccbbb4..f385139 100644
--- a/src/demo/test.ts
+++ b/src/demo/test.ts
@@ -1,6 +1,7 @@
 import { Queryable } from "../implements/queryable";
+const cTable = require('console.table');
 
-let players = new Promise((resolve, reject) => {
+let players = new Promise<{ name, overall, nationId, skills }[]>((resolve, reject) => {
     // skills: attack, stamia, speed, shoot
     console.log('get players...');
     setTimeout(() => {
@@ -36,28 +37,19 @@ let continents = new Promise<{ id, areaName }[]>(resolve => {
     }, 2300);
 })
 
-
 function main() {
-    // Just query not execute query
-    console.time('querytime');
     let query = Queryable
-            .from(nations)
-            .join(continents, (x, y) => x.areaId === y.id)
-            .groupBy(o => o.y.areaName)
-            .select(x => {
-                return {
-                    area: x.key,
-                    total: Queryable.fromSync(x.items).count()
-                }
-            })
-
-
-    console.timeEnd('querytime');
+        .from(nations)
+        .join(continents, (x, y) => x.areaId === y.id)
+        .groupBy(o => o.y.areaName)
+        .select(x => {
+            return {
+                area: x.key,
+                total: Queryable.fromSync(x.items).count()
+            }
+        })
 
-    console.time('executetime');
     const data = query.toList().then(data => {
-        console.timeEnd('executetime');
-        console.log(data);
         console.table(data);
     });
 }
diff --git a/src/implements/methods.ts b/src/implements/methods.ts
index cb6831e..f5c1b7a 100644
--- a/src/implements/methods.ts
+++ b/src/implements/methods.ts
@@ -75,25 +75,25 @@ export class IteratorMethods<T> implements IMethods<T> {
     }
 
     first(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return new FirstClause(iterator).execute(data) as T;
         });
     }
 
     firstOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new FirstClause(iterator).execute(data) || null) as T;
         });
     }
 
     last(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return new LastClause(iterator).execute(data) as T;
         });
     }
 
     lastOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new LastClause(iterator).execute(data) || null) as T;
         });
     }
@@ -106,31 +106,31 @@ export class IteratorMethods<T> implements IMethods<T> {
 
 
     sum<S>(iterator: (entity: T) => S): Promise<number> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new SumClause(iterator).execute(data) || null) as number;
         });
     }
 
     avarage<S>(iterator: (entity: T) => S): Promise<number> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new AvarageClause(iterator).execute(data) || 0) as number;
         });
     }
 
     min<S>(iterator: (entity: T) => S): Promise<number> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new MinClause(iterator).execute(data) || null) as number;
         });
     }
 
     max<S>(iterator: (entity: T) => S): Promise<number> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return (new MaxClause(iterator).execute(data) || null) as number;
         });
     }
 
     single(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             if (!data) throw new Error("Single require source is not null");
             return new SingleClause(iterator).execute(data);
 
@@ -138,7 +138,7 @@ export class IteratorMethods<T> implements IMethods<T> {
     }
 
     singleOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return new SingleClause(iterator).execute(data) || null;
         });
     }
@@ -164,13 +164,13 @@ export class IteratorMethods<T> implements IMethods<T> {
     }
 
     any<T>(iterator: (entity: T) => boolean): Promise<boolean> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return new AnyClause(iterator).execute(data);
         });
     }
 
     contains(entity: T): Promise<boolean> {
-        return this.toList().then((data: T[]) => {
+        return this.filterReturn(this.toList(), (data) => {
             return new ContainsClause(entity).execute(data);
         });
     }
diff --git a/src/intefaces/methods.interface.ts b/src/intefaces/methods.interface.ts
index 7376b75..b7c0a35 100644
--- a/src/intefaces/methods.interface.ts
+++ b/src/intefaces/methods.interface.ts
@@ -21,7 +21,7 @@ export interface IMethods<T> {
     sum<S>(iterator: (entity: T) => S): Promise<number>;
     min<S>(iterator: (entity: T) => S): Promise<number>;
     max<S>(iterator: (entity: T) => S): Promise<number>;
-    avarage<S>(iterator: (entity: T) => S): Promise<number>;
+    avarage<S>(iterator?: (entity: T) => S): Promise<number>;
     any<T>(iterator: (entity: T) => boolean): Promise<boolean>;
     contains(entity: T): Promise<boolean>;
 
diff --git a/src/methods/average.ts b/src/methods/average.ts
index 075e01c..6b41707 100644
--- a/src/methods/average.ts
+++ b/src/methods/average.ts
@@ -9,11 +9,12 @@ export class AvarageClause<T> extends BaseIterator<T> implements IIterator<T> {
     execute(source: any[] | T[]): T[] | T | any {
         if (!source) return 0;
 
-        let _result = new SelectClause(this._iterator).execute(source) as number[];
+        let _result = this._iterator
+            ? new SelectClause(this._iterator).execute(source) as number[]
+            : source;
 
         if (!_result) return 0;
-
-        if (!Number.isNaN(_result[0])) throw new Error("Avarage operator need type of number");
+        if (Number.isNaN(_result[0])) throw new Error("Avarage operator need type of number");
 
         return (_result.reduce((a, b) => a + b, 0)) / _result.length;
     }