diff --git a/codegen/object.go b/codegen/object.go
index 93d1952102..041c99c748 100644
--- a/codegen/object.go
+++ b/codegen/object.go
@@ -217,23 +217,49 @@ func (f *Field) doWriteJson(val string, remainingMods []string, astType *ast.Typ
 			usePtr = true
 		}
 
-		return tpl(`{{.arr}} := graphql.Array{}
+		return tpl(`
+			{{.arr}} := make(graphql.Array, len({{.val}}))
+			{{ if and .top (not .isScalar) }} var wg sync.WaitGroup {{ end }}
+			{{ if not .isScalar }}
+				isLen1 := len({{.val}}) == 1 
+				if !isLen1 {
+					wg.Add(len({{.val}}))
+				}
+			{{ end }}
 			for {{.index}} := range {{.val}} {
 				{{- if not .isScalar }}
+					{{.index}} := {{.index}}
 					rctx := &graphql.ResolverContext{
 						Index: &{{.index}},
 						Result: {{ if .usePtr }}&{{end}}{{.val}}[{{.index}}],
 					}
 					ctx := graphql.WithResolverContext(ctx, rctx)
+					f := func({{.index}} int) {
+						if !isLen1 {
+							defer wg.Done()
+						}
+						{{.arr}}[{{.index}}] = func() graphql.Marshaler {
+							{{ .next }} 
+						}()
+					}
+					if isLen1 {
+						f({{.index}})
+					} else {
+						go f({{.index}})
+					}
+				{{ else }}
+					{{.arr}}[{{.index}}] = func() graphql.Marshaler {
+						{{ .next }} 
+					}()
 				{{- end}}
-				{{.arr}} = append({{.arr}}, func() graphql.Marshaler {
-					{{ .next }} 
-				}())
 			}
+			{{ if and .top (not .isScalar) }} wg.Wait() {{ end }}
 			return {{.arr}}`, map[string]interface{}{
 			"val":      val,
 			"arr":      arr,
 			"index":    index,
+			"top":      depth == 1,
+			"arrayLen": len(val),
 			"isScalar": f.IsScalar,
 			"usePtr":   usePtr,
 			"next":     f.doWriteJson(val+"["+index+"]", remainingMods[1:], astType.Elem, false, depth+1),
diff --git a/codegen/testserver/generated.go b/codegen/testserver/generated.go
index 3402ee3dce..e300041d2b 100644
--- a/codegen/testserver/generated.go
+++ b/codegen/testserver/generated.go
@@ -872,33 +872,74 @@ func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field grap
 	}
 	res := resTmp.([][]*OuterObject)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
-			arr2 := graphql.Array{}
-			for idx2 := range res[idx1] {
-				rctx := &graphql.ResolverContext{
-					Index:  &idx2,
-					Result: res[idx1][idx2],
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				arr2 := make(graphql.Array, len(res[idx1]))
+
+				isLen1 := len(res[idx1]) == 1
+				if !isLen1 {
+					wg.Add(len(res[idx1]))
 				}
-				ctx := graphql.WithResolverContext(ctx, rctx)
-				arr2 = append(arr2, func() graphql.Marshaler {
 
-					if res[idx1][idx2] == nil {
-						return graphql.Null
+				for idx2 := range res[idx1] {
+					idx2 := idx2
+					rctx := &graphql.ResolverContext{
+						Index:  &idx2,
+						Result: res[idx1][idx2],
+					}
+					ctx := graphql.WithResolverContext(ctx, rctx)
+					f := func(idx2 int) {
+						if !isLen1 {
+							defer wg.Done()
+						}
+						arr2[idx2] = func() graphql.Marshaler {
+
+							if res[idx1][idx2] == nil {
+								return graphql.Null
+							}
+
+							return ec._OuterObject(ctx, field.Selections, res[idx1][idx2])
+						}()
+					}
+					if isLen1 {
+						f(idx2)
+					} else {
+						go f(idx2)
 					}
 
-					return ec._OuterObject(ctx, field.Selections, res[idx1][idx2])
-				}())
-			}
-			return arr2
-		}())
+				}
+
+				return arr2
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
+
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -957,22 +998,43 @@ func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]*Shape)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
-
-			if res[idx1] == nil {
-				return graphql.Null
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
 			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				if res[idx1] == nil {
+					return graphql.Null
+				}
+
+				return ec._Shape(ctx, field.Selections, res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Shape(ctx, field.Selections, res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1546,12 +1608,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -1574,18 +1639,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1819,18 +1905,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2101,18 +2208,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2213,18 +2341,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2366,18 +2515,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2397,18 +2567,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2428,18 +2619,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2471,18 +2683,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2502,18 +2735,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/chat/generated.go b/example/chat/generated.go
index b9be4e6d37..588d5f884b 100644
--- a/example/chat/generated.go
+++ b/example/chat/generated.go
@@ -196,18 +196,39 @@ func (ec *executionContext) _Chatroom_messages(ctx context.Context, field graphq
 	}
 	res := resTmp.([]Message)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Message(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Message(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -726,12 +747,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -754,18 +778,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -999,18 +1044,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1281,18 +1347,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1393,18 +1480,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1546,18 +1654,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1577,18 +1706,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1608,18 +1758,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1651,18 +1822,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1682,18 +1874,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/config/generated.go b/example/config/generated.go
index fa61d1c989..5f6f51403c 100644
--- a/example/config/generated.go
+++ b/example/config/generated.go
@@ -226,18 +226,39 @@ func (ec *executionContext) _Query_todos(ctx context.Context, field graphql.Coll
 	}
 	res := resTmp.([]Todo)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Todo(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Todo(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -648,12 +669,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -676,18 +700,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -921,18 +966,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1203,18 +1269,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1315,18 +1402,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1468,18 +1576,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1499,18 +1628,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1530,18 +1680,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1573,18 +1744,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1604,18 +1796,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/dataloader/generated.go b/example/dataloader/generated.go
index 278d5f7285..8ad2fc63ed 100644
--- a/example/dataloader/generated.go
+++ b/example/dataloader/generated.go
@@ -325,18 +325,39 @@ func (ec *executionContext) _Customer_orders(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Order)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Order(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Order(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -521,18 +542,39 @@ func (ec *executionContext) _Order_items(ctx context.Context, field graphql.Coll
 	}
 	res := resTmp.([]Item)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Item(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Item(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -604,18 +646,39 @@ func (ec *executionContext) _Query_customers(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Customer)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Customer(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Customer(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -658,18 +721,39 @@ func (ec *executionContext) _Query_torture1d(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Customer)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Customer(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Customer(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -723,29 +807,70 @@ func (ec *executionContext) _Query_torture2d(ctx context.Context, field graphql.
 	}
 	res := resTmp.([][]Customer)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
-			arr2 := graphql.Array{}
-			for idx2 := range res[idx1] {
-				rctx := &graphql.ResolverContext{
-					Index:  &idx2,
-					Result: &res[idx1][idx2],
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				arr2 := make(graphql.Array, len(res[idx1]))
+
+				isLen1 := len(res[idx1]) == 1
+				if !isLen1 {
+					wg.Add(len(res[idx1]))
 				}
-				ctx := graphql.WithResolverContext(ctx, rctx)
-				arr2 = append(arr2, func() graphql.Marshaler {
 
-					return ec._Customer(ctx, field.Selections, &res[idx1][idx2])
-				}())
-			}
-			return arr2
-		}())
+				for idx2 := range res[idx1] {
+					idx2 := idx2
+					rctx := &graphql.ResolverContext{
+						Index:  &idx2,
+						Result: &res[idx1][idx2],
+					}
+					ctx := graphql.WithResolverContext(ctx, rctx)
+					f := func(idx2 int) {
+						if !isLen1 {
+							defer wg.Done()
+						}
+						arr2[idx2] = func() graphql.Marshaler {
+
+							return ec._Customer(ctx, field.Selections, &res[idx1][idx2])
+						}()
+					}
+					if isLen1 {
+						f(idx2)
+					} else {
+						go f(idx2)
+					}
+
+				}
+
+				return arr2
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
+
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -911,12 +1036,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -939,18 +1067,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1184,18 +1333,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1466,18 +1636,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1578,18 +1769,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1731,18 +1943,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1762,18 +1995,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1793,18 +2047,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1836,18 +2111,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1867,18 +2163,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/scalars/generated.go b/example/scalars/generated.go
index b10520bbe0..b44bc68e07 100644
--- a/example/scalars/generated.go
+++ b/example/scalars/generated.go
@@ -277,18 +277,39 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]model.User)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._User(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._User(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -687,12 +708,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -715,18 +739,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -960,18 +1005,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1242,18 +1308,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1354,18 +1441,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1507,18 +1615,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1538,18 +1667,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1569,18 +1719,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1612,18 +1783,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1643,18 +1835,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/selection/generated.go b/example/selection/generated.go
index ceaa5d93c6..f49b0a6e02 100644
--- a/example/selection/generated.go
+++ b/example/selection/generated.go
@@ -176,12 +176,15 @@ func (ec *executionContext) _Like_selection(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -201,12 +204,15 @@ func (ec *executionContext) _Like_collected(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -309,12 +315,15 @@ func (ec *executionContext) _Post_selection(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -334,12 +343,15 @@ func (ec *executionContext) _Post_collected(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -399,18 +411,39 @@ func (ec *executionContext) _Query_events(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]Event)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Event(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Event(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -576,12 +609,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -604,18 +640,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -849,18 +906,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1131,18 +1209,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1243,18 +1342,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1396,18 +1516,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1427,18 +1568,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1458,18 +1620,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1501,18 +1684,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1532,18 +1736,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/starwars/generated.go b/example/starwars/generated.go
index 8237b1371d..9213b5753f 100644
--- a/example/starwars/generated.go
+++ b/example/starwars/generated.go
@@ -238,18 +238,39 @@ func (ec *executionContext) _Droid_friends(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]Character)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Character(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Character(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -327,12 +348,15 @@ func (ec *executionContext) _Droid_appearsIn(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Episode)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return res[idx1]
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -441,18 +465,39 @@ func (ec *executionContext) _FriendsConnection_edges(ctx context.Context, field
 	}
 	res := resTmp.([]FriendsEdge)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._FriendsEdge(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._FriendsEdge(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -472,18 +517,39 @@ func (ec *executionContext) _FriendsConnection_friends(ctx context.Context, fiel
 	}
 	res := resTmp.([]Character)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Character(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Character(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -766,18 +832,39 @@ func (ec *executionContext) _Human_friends(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]Character)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Character(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Character(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -855,12 +942,15 @@ func (ec *executionContext) _Human_appearsIn(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Episode)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return res[idx1]
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -880,18 +970,39 @@ func (ec *executionContext) _Human_starships(ctx context.Context, field graphql.
 	}
 	res := resTmp.([]Starship)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Starship(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Starship(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1238,18 +1349,39 @@ func (ec *executionContext) _Query_reviews(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]Review)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Review(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Review(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1284,18 +1416,39 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]SearchResult)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._SearchResult(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._SearchResult(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1744,18 +1897,24 @@ func (ec *executionContext) _Starship_history(ctx context.Context, field graphql
 	}
 	res := resTmp.([][]int)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
-			arr2 := graphql.Array{}
+		arr1[idx1] = func() graphql.Marshaler {
+
+			arr2 := make(graphql.Array, len(res[idx1]))
+
 			for idx2 := range res[idx1] {
-				arr2 = append(arr2, func() graphql.Marshaler {
+				arr2[idx2] = func() graphql.Marshaler {
 					return graphql.MarshalInt(res[idx1][idx2])
-				}())
+				}()
 			}
+
 			return arr2
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -1861,12 +2020,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -1889,18 +2051,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2134,18 +2317,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2416,18 +2620,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2528,18 +2753,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2681,18 +2927,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2712,18 +2979,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2743,18 +3031,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2786,18 +3095,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -2817,18 +3147,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/example/todo/generated.go b/example/todo/generated.go
index 13164a1e6e..49485cb0e4 100644
--- a/example/todo/generated.go
+++ b/example/todo/generated.go
@@ -346,18 +346,39 @@ func (ec *executionContext) _MyQuery_todos(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]Todo)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec._Todo(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Todo(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -629,12 +650,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -657,18 +681,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -902,18 +947,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1184,18 +1250,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1296,18 +1383,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1449,18 +1557,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1480,18 +1609,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1511,18 +1661,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1554,18 +1725,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1585,18 +1777,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
diff --git a/integration/generated.go b/integration/generated.go
index 1bbad67243..bf648ad6f6 100644
--- a/integration/generated.go
+++ b/integration/generated.go
@@ -203,12 +203,15 @@ func (ec *executionContext) _Element_mismatched(ctx context.Context, field graph
 	}
 	res := resTmp.([]bool)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalBoolean(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -301,22 +304,43 @@ func (ec *executionContext) _Query_path(ctx context.Context, field graphql.Colle
 	}
 	res := resTmp.([]*models.Element)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
-
-			if res[idx1] == nil {
-				return graphql.Null
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
 			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				if res[idx1] == nil {
+					return graphql.Null
+				}
+
+				return ec._Element(ctx, field.Selections, res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec._Element(ctx, field.Selections, res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -575,12 +599,15 @@ func (ec *executionContext) _User_likes(ctx context.Context, field graphql.Colle
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -737,12 +764,15 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr
 	}
 	res := resTmp.([]string)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+
 	for idx1 := range res {
-		arr1 = append(arr1, func() graphql.Marshaler {
+		arr1[idx1] = func() graphql.Marshaler {
 			return graphql.MarshalString(res[idx1])
-		}())
+		}()
 	}
+
 	return arr1
 }
 
@@ -765,18 +795,39 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1010,18 +1061,39 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1292,18 +1364,39 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1404,18 +1497,39 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap
 	}
 	res := resTmp.([]introspection.Directive)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Directive(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Directive(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1557,18 +1671,39 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co
 	}
 	res := resTmp.([]introspection.Field)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Field(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Field(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1588,18 +1723,39 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1619,18 +1775,39 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra
 	}
 	res := resTmp.([]introspection.Type)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___Type(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___Type(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1662,18 +1839,39 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq
 	}
 	res := resTmp.([]introspection.EnumValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___EnumValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }
 
@@ -1693,18 +1891,39 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph
 	}
 	res := resTmp.([]introspection.InputValue)
 	rctx.Result = res
-	arr1 := graphql.Array{}
+
+	arr1 := make(graphql.Array, len(res))
+	var wg sync.WaitGroup
+
+	isLen1 := len(res) == 1
+	if !isLen1 {
+		wg.Add(len(res))
+	}
+
 	for idx1 := range res {
+		idx1 := idx1
 		rctx := &graphql.ResolverContext{
 			Index:  &idx1,
 			Result: &res[idx1],
 		}
 		ctx := graphql.WithResolverContext(ctx, rctx)
-		arr1 = append(arr1, func() graphql.Marshaler {
+		f := func(idx1 int) {
+			if !isLen1 {
+				defer wg.Done()
+			}
+			arr1[idx1] = func() graphql.Marshaler {
+
+				return ec.___InputValue(ctx, field.Selections, &res[idx1])
+			}()
+		}
+		if isLen1 {
+			f(idx1)
+		} else {
+			go f(idx1)
+		}
 
-			return ec.___InputValue(ctx, field.Selections, &res[idx1])
-		}())
 	}
+	wg.Wait()
 	return arr1
 }