code: def _parse_container(tokens, index, for_or_if=None):
      
  
      # Store the opening bracket.
      items = [Atom(Token(*tokens[index]))]
      index += 1
  
      num_tokens = len(tokens)
      while index < num_tokens:
          tok = Token(*tokens[index])
  
          if tok.token_string in ',)]}':
              # First check if we're at the end of a list comprehension or
              # if-expression. Don't add the ending token as part of the list
              # comprehension or if-expression, because they aren't part of those
              # constructs.
              if for_or_if == 'for':
                  return (ListComprehension(items), index - 1)
  
              elif for_or_if == 'if':
                  return (IfExpression(items), index - 1)
  
              # We've reached the end of a container.
              items.append(Atom(tok))
  
              # If not, then we are at the end of a container.
              if tok.token_string == ')':
                  # The end of a tuple.
                  return (Tuple(items), index)
  
              elif tok.token_string == ']':
                  # The end of a list.
                  return (List(items), index)
  
              elif tok.token_string == '}':
                  # The end of a dictionary or set.
                  return (DictOrSet(items), index)
  
          elif tok.token_string in '([{':
              # A sub-container is being defined.
              (container, index) = _parse_container(tokens, index)
              items.append(container)
  
          elif tok.token_string == 'for':
              (container, index) = _parse_container(tokens, index, 'for')
              items.append(container)
  
          elif tok.token_string == 'if':
              (container, index) = _parse_container(tokens, index, 'if')
              items.append(container)
  
          else:
              items.append(Atom(tok))
  
          index += 1
  
      return (None, None)
docs: Parse a high-level container, such as a list, tuple, etc.