enum_list : enum_list COMMA ENUM_VAL
                     | ENUM_VAL
                     | empty
552819
def p_enum_list(self, p):
        ''''''
        if p[1] is None:
            p[0] = []
        elif len(p) == 4:
            p[1].append(p[3])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
837862
def _space_delimited_list(value):
    '''
    
    '''
    if isinstance(value, six.string_types):
        items = value.split(' ')
        valid = items and all(items)
    else:
        valid = hasattr(value, '__iter__') and (value != [])

    if valid:
        return True, 'space-delimited string'
    return False, '{0} is not a valid list.\n'.format(value)
310339
def ordered_list(text_array):
    
    text_list = []
    for number, item in enumerate(text_array):
        text_list.append(
            (esc_format(number + 1) + ".").ljust(3) + " " + esc_format(item)
        )
    return "\n".join(text_list)
792828
def _get_stringlist_from_commastring(self, field):
        # type: (str) -> List[str]
        
        strings = self.data.get(field)
        if strings:
            return strings.split(',')
        else:
            return list()
493614
def p_encaps_list_string(p):
    ''
    if p[1] == '':
        p[0] = p[2].decode('string_escape')
    else:
        p[0] = ast.BinaryOp('.', p[1], p[2].decode('string_escape'),
                            lineno=p.lineno(2))
186112
def parse_list(lexer: Lexer, is_const: bool) -> ListValueNode:
    """"""
    start = lexer.token
    item = parse_const_value if is_const else parse_value_value
    return ListValueNode(
        values=any_nodes(lexer, TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),
        loc=loc(lexer, start),
    )
76852
function enums(schema, defaults, options) {
  const e = en(schema, undefined, options)
  const l = list([e], defaults, options)
  return l
}
876605
def toList(variable, types=(basestring, int, float, )):
    
    if isinstance(variable, types):
        return [variable]
    else:
        return variable
78525
def enum_choice_list(data):
    

    # transform enum types, otherwise assume list of string choices
    if not data:
        return {}
    try:
        choices = [x.value for x in data]
    except AttributeError:
        choices = data

    def _type(value):
        return next((x for x in choices if x.lower() == value.lower()), value) if value else value
    params = {
        'choices': CaseInsensitiveList(choices),
        'type': _type
    }
    return params
1149294
def _format_param_val(self, param_val):
        
        if isinstance(param_val, list):
            return ' '.join(str(x) for x in param_val)
        else:
            return str(param_val)
1179184
def encode_list(cls, value):
        
        encoded = base64.b64encode(six.b(" ".join(str(v) for v in value) or "-"))
        return encoded.decode("utf-8") if six.PY3 else encoded
211197
def list(type, sym, count: nil)
      if count
        raise BadCountError unless count.positive?
      end

      @expected << [:list, type, sym, count]
    end
659523
def prefix_list(self, prefix, values):
        
        return list(map(lambda value: prefix + " " + value, values))
206355
def enumeration_to_list(enm):
    
    result = []
    while javabridge.call(enm, "hasMoreElements", "()Z"):
        result.append(javabridge.call(enm, "nextElement", "()Ljava/lang/Object;"))
    return result
1012671
def to_list_str(value, encode=None):
    
    result = []
    for index, v in enumerate(value):
        if isinstance(v, dict):
            result.append(to_dict_str(v, encode))
            continue

        if isinstance(v, list):
            result.append(to_list_str(v, encode))
            continue

        if encode:
            result.append(encode(v))
        else:
            result.append(default_encode(v))

    return result
45965
def p_const_vector_elem_list_list(p):
    
    if p[1] is None or p[3] is None:
        return

    if not is_static(p[3]):
        if isinstance(p[3], symbols.UNARY):
            tmp = make_constexpr(p.lineno(2), p[3])
        else:
            api.errmsg.syntax_error_not_constant(p.lineno(2))
            p[0] = None
            return
    else:
        tmp = p[3]

    if p[1] is not None:
        p[1].append(tmp)
    p[0] = p[1]
215970
public final void mVALUE_LIST() throws RecognitionException {
        try {
            int _type = VALUE_LIST;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BELScript.g:273:11: ( '{' ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )? ( COMMA ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )? )* '}' )
            // BELScript.g:274:5: '{' ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )? ( COMMA ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )? )* '}'
            {
            match('{'); 
            // BELScript.g:274:9: ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )?
            int alt4=4;
            switch ( input.LA(1) ) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'P':
                case 'Q':
                case 'R':
                case 'S':
                case 'T':
                case 'U':
                case 'V':
                case 'W':
                case 'X':
                case 'Y':
                case 'Z':
                case '_':
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'w':
                case 'x':
                case 'y':
                case 'z':
                    {
                    alt4=1;
                    }
                    break;
                case '\"':
                    {
                    alt4=2;
                    }
                    break;
                case '{':
                    {
                    alt4=3;
                    }
                    break;
            }

            switch (alt4) {
                case 1 :
                    // BELScript.g:274:10: OBJECT_IDENT
                    {
                    mOBJECT_IDENT(); 

                    }
                    break;
                case 2 :
                    // BELScript.g:274:25: QUOTED_VALUE
                    {
                    mQUOTED_VALUE(); 

                    }
                    break;
                case 3 :
                    // BELScript.g:274:40: VALUE_LIST
                    {
                    mVALUE_LIST(); 

                    }
                    break;

            }

            // BELScript.g:274:53: ( COMMA ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )? )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==' '||LA6_0==',') ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // BELScript.g:274:54: COMMA ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )?
            	    {
            	    mCOMMA(); 
            	    // BELScript.g:274:60: ( OBJECT_IDENT | QUOTED_VALUE | VALUE_LIST )?
            	    int alt5=4;
            	    switch ( input.LA(1) ) {
            	        case '0':
            	        case '1':
            	        case '2':
            	        case '3':
            	        case '4':
            	        case '5':
            	        case '6':
            	        case '7':
            	        case '8':
            	        case '9':
            	        case 'A':
            	        case 'B':
            	        case 'C':
            	        case 'D':
            	        case 'E':
            	        case 'F':
            	        case 'G':
            	        case 'H':
            	        case 'I':
            	        case 'J':
            	        case 'K':
            	        case 'L':
            	        case 'M':
            	        case 'N':
            	        case 'O':
            	        case 'P':
            	        case 'Q':
            	        case 'R':
            	        case 'S':
            	        case 'T':
            	        case 'U':
            	        case 'V':
            	        case 'W':
            	        case 'X':
            	        case 'Y':
            	        case 'Z':
            	        case '_':
            	        case 'a':
            	        case 'b':
            	        case 'c':
            	        case 'd':
            	        case 'e':
            	        case 'f':
            	        case 'g':
            	        case 'h':
            	        case 'i':
            	        case 'j':
            	        case 'k':
            	        case 'l':
            	        case 'm':
            	        case 'n':
            	        case 'o':
            	        case 'p':
            	        case 'q':
            	        case 'r':
            	        case 's':
            	        case 't':
            	        case 'u':
            	        case 'v':
            	        case 'w':
            	        case 'x':
            	        case 'y':
            	        case 'z':
            	            {
            	            alt5=1;
            	            }
            	            break;
            	        case '\"':
            	            {
            	            alt5=2;
            	            }
            	            break;
            	        case '{':
            	            {
            	            alt5=3;
            	            }
            	            break;
            	    }

            	    switch (alt5) {
            	        case 1 :
            	            // BELScript.g:274:61: OBJECT_IDENT
            	            {
            	            mOBJECT_IDENT(); 

            	            }
            	            break;
            	        case 2 :
            	            // BELScript.g:274:76: QUOTED_VALUE
            	            {
            	            mQUOTED_VALUE(); 

            	            }
            	            break;
            	        case 3 :
            	            // BELScript.g:274:91: VALUE_LIST
            	            {
            	            mVALUE_LIST(); 

            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);

            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }