class GraphQL::ListType


Given a list type, you can always get the underlying type with {#unwrap}.
end
argument :values, types.String.to_list_type
# or
argument :values, types[types.String]
# …
field :newNames do
@example A field which accepts a list of strings
For input types, it says that the incoming value will be a list of the modified type.
field :items, ItemType.to_list_type
# or
field :items, types[ItemType]
@example A field which returns a list of items
For return types, it says that the returned value will be a list of the modified.
or {BaseType#to_list_type} (‘InnerType.to_list_type`)
List types can be created with the type helper (`types`)
A list type modifies another type.

def coerce_non_null_input(value, ctx) 

def coerce_non_null_input(value, ctx)
  ensure_array(value).map { |item| of_type.coerce_input(item, ctx) }
end

def coerce_result(value, ctx = nil) 

def coerce_result(value, ctx = nil)
  if ctx.nil?
    warn_deprecated_coerce("coerce_isolated_result")
    ctx = GraphQL::Query::NullContext
  end
  ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
end

def ensure_array(value) 

def ensure_array(value)
  value.is_a?(Array) ? value : [value]
end

def initialize(of_type:) 

def initialize(of_type:)
  super()
  @of_type = of_type
end

def kind 

def kind
  GraphQL::TypeKinds::LIST
end

def list? 

def list?
  true
end

def to_s 

def to_s
  "[#{of_type.to_s}]"
end

def validate_non_null_input(value, ctx) 

def validate_non_null_input(value, ctx)
  result = GraphQL::Query::InputValidationResult.new
  ensure_array(value).each_with_index do |item, index|
    item_result = of_type.validate_input(item, ctx)
    if !item_result.valid?
      result.merge_result!(index, item_result)
    end
  end
  result
end