ListValue[Const]
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),
    )
451031
function listToObject(list, key) {
        var length, result, i, obj, keyValue;
        if (!list) {
            list = [];
        }
        length = list.length;
        result = { valids: {}, discarded: [] };
        for (i = 0; i < length; i += 1) {
            obj = list[i];
            keyValue = obj[key];
            // discard the object without a key
            if (keyValue) {
                result.valids[keyValue] = obj;
            } else {
                result.discarded.push(obj);
            }
        }
        return result;
    }
741385
function updateListToMP (vnodeList = [], val, forInfo, context) {
  let firstItem = vnodeList[0]
  let forKeys
  let list = []
  if (!firstItem) {
    vnodeList.push(new VNode('div'))
    firstItem = vnodeList[0]
  }

  /* istanbul ignore else */
  if (firstItem) {
    // collect v-key
    if (Array.isArray(firstItem)) {
      forKeys = firstItem.map(e => {
        const { attrs = {}} = e.data || /* istanbul ignore next */ {}
        const { k_ = '' } = attrs
        return k_
      })
    } else {
      const { attrs = {}} = firstItem.data || {}
      const { k_ = '' } = attrs
      forKeys = [k_]
    }

    forKeys = forKeys.filter(e => e)

    // generate list array with v-key value
    let valToList = []
    /* istanbul ignore else */
    if (Array.isArray(val) || typeof val === 'string') {
      valToList = new Array(val.length)
      for (let i = 0, l = val.length; i < l; i++) {
        valToList[i] = val[i]
      }
    } else if (typeof val === 'number') {
      valToList = new Array(val)
      for (let i = 0; i < val; i++) {
        valToList[i] = i
      }
    } else if (isObject(val)) {
      valToList = Object.keys(val).map((e, i) => i)
    }

    list = valToList.map((e, i) => {
      if (forKeys.length === 0) {
        return i
      }
      return forKeys.reduce((res, k) => {
        res[k.replace(/\./g, '_')] = getValue(val[i], k)
        return res
      }, {})
    })
  }

  const cloneVnode = {
    context,
    data: {
      attrs: { h_: forInfo[0], f_: forInfo[1] }
    }
  }

  // TODO: try not disable key diff in patching process
  // key will reuse existing vnode which won't update the vnode content
  // see unit test: with key
  // list won't update after this.list.reverse() if it's not disable

  // if is a scoped slot list
  if (firstItem && !firstItem.fn) {
    vnodeList.forEach(vnode => {
      if (Array.isArray(vnode)) {
        vnode.forEach(c => {
          delete c.key
        })
      } else {
        delete vnode.key
      }
    })
  }

  updateVnodeToMP(cloneVnode, HOLDER_TYPE_VARS.for, list)

  const fnStoreNode = Array.isArray(firstItem) ? firstItem[0] : firstItem

  if (fnStoreNode) {
    fnStoreNode.__renderListFn = function (vnode) {
      updateVnodeToMP(vnode || cloneVnode, HOLDER_TYPE_VARS.for, list)
    }

    fnStoreNode.__renderListVnode = cloneVnode
  }
}
1033630
def p_const_vector_elem_list(p):
    
    if p[1] is None:
        return

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

    p[0] = [tmp]
1185263
public static final int findValueInListBox(ListBox list, String value) {
	for (int i=0; i<list.getItemCount(); i++) {
	    if (value.equals(list.getValue(i))) {
		return i;
	    }
	}
	return -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 {
        }
    }
1008478
def pretty_const(self, index):
        

        t, v = self.consts[index]
        if not t:
            return None, None
        else:
            return _pretty_const_type_val(t, v)
309485
function apivalueFromValue(value) {
  const composedValue = (componentKind) => {
    const elements = value[componentKind].map((it) => {
      const apiValue = apivalueFromValue(it);
      const value = apiValue && apiValue.value;

      return value;
    });

    return {
      type: value.type().toString(),
      value: elements
    };
  };

  if (value === null) {
    return null;
  }
  if (value.isInteger()) {
    return {
      type: i18n('TYPE:Integer'),
      value: value.asNumber()
    };
  } else if (value.isBoolean()) {
    return {
      type: i18n('TYPE:Bool'),
      value: boolFromValue(value)
    };
  } else if (value.isString()) {
    return {
      type: i18n('TYPE:String'),
      value: value.string
    };
  } else if (value.isTuple()) {
    return composedValue('components');
  } else if (value.isList()) {
    return composedValue('elements');
  } else if (value.isStructure()) {
    return {
      type: value.typeName,
      value: value.toString()
    };
  } else {
    return {
      type: value.type().toString(),
      value: value.toString()
    };
  }
}
623493
function List(props) {
  warnAboutDeprecatedProp(props.mods, 'mods', 'className');

  const {
    align,
    className,
    dataAttrs,
    hideBullets,
    items,
  } = props;

  const mods = props.mods ? props.mods.slice() : [];

  mods.push(`align_${align}`);

  if (hideBullets) {
    mods.push("no-bullets");
  }

  const listClasses = classNames(getClassNamesWithMods('ui-list', mods), className);

  const itemsBlock = items.filter(Boolean).map((item, index) => (
    <li className="ui-list__item" key={index}>
      {item}
    </li>
  ));

  return (
    <ul className={listClasses} {...getDataAttributes(dataAttrs)}>
      {itemsBlock}
    </ul>
  );
}
1228266
function(list, delim) {
            return new Anonymous(!isArray(list.value)
                ? list.toCSS()
                : list.value.map(function(a) {
                    return toString(a, "", "");
                }).join(delim ? delim.value : ", "));
        }
1259141
function makeValueChecker(ref) {
	const expected = require(ref);
	return ({value}) => value === expected || value === expected.default;
}
134617
function(list, value) {
      if (_.isArray(list)) {
        for (var i = 0; i < list.length; i++) {
          var listItem = list[i];
          if (listItem.indexOf(value) === 0) {
            return true;
          }
        }
      } else {
        if (list.indexOf(value) === 0) {
          return true;
        }
      }
      return false;
    }
743527
function normalizeList (val, name) {
  var list = [].concat(val || [])

  for (var i = 0; i < list.length; i++) {
    if (typeof list[i] !== 'string') {
      throw new TypeError(name + ' must be array of strings or false')
    }
  }

  return list
}
1117791
def RenderValue(value, limit_lists=-1):
  """"""

  if value is None:
    return None

  renderer = ApiValueRenderer.GetRendererForValueOrClass(
      value, limit_lists=limit_lists)
  return renderer.RenderValue(value)
879277
private <T> List<T> getAsList(T passedValue) {
    if (passedValue == null) {
      return null;
    }
    List<T> result = new ArrayList<T>();
    result.add(passedValue);
    return result;
  }
857019
private void appendListOfValues(ClassDescriptor cld, StringBuffer stmt)
    {
        FieldDescriptor[] fields = cld.getAllRwFields();

        if(fields.length == 0)
        {
            return;
        }

        stmt.append(" VALUES (");
        for(int i = 0; i < fields.length; i++)
        {
            stmt.append("?");
            if(i < fields.length - 1)
            {
                stmt.append(",");
            }
        }
        stmt.append(") ");
    }
483129
private Object[] parseValue(List<SQLExpr> targetList) throws SqlParseException {
        Object[] value = new Object[targetList.size()];
        for (int i = 0; i < targetList.size(); i++) {
            value[i] = parseValue(targetList.get(i));
        }
        return value;
    }