List(Elements) -> List(Entries)
358637
protected List<Entry> parseEntries(final Feed feed, final String baseURI, final List<Element> eEntries, final Locale locale) {

        final List<Entry> entries = new ArrayList<Entry>();
        for (final Element entry : eEntries) {
            entries.add(this.parseEntry(feed, entry, baseURI, locale));
        }

        return Lists.emptyToNull(entries);

    }
208243
private boolean putInList(Entry entry) {
        FilterCellFastStr currentCell = firstCell;
        FilterCellFastStr nextCell = null;

        int[] hashcodes = entry.getHashcodes();
        int[] lengths = entry.getLengths();

        // work from back to front
        int lastIndex = entry.getCurrentSize() - 1;

        for (int i = lastIndex; i >= 0; i--) {
            // test for wildcard
            if ((hashcodes[i] == 0) && (lengths[i] == 0)) {
                currentCell.addNewCell(hashcodes[i], lengths[i]);
                return true;
            }
            // check in nextCell has different lengths, if so, then
            // we can't use this "fast" method
            nextCell = currentCell.findNextCell(hashcodes[i]);
            if (nextCell != null) {
                if (nextCell.getHashLength() != lengths[i]) {
                    return false;
                }
            }

            if (nextCell == null) { // new address, complete the tree
                for (int j = i; j >= 0; j--) {
                    currentCell = currentCell.addNewCell(hashcodes[j], lengths[j]);
                    if ((hashcodes[j] == 0) && (lengths[j] == 0)) {
                        // nothing can come before a wildcard, so return
                        return true;
                    }
                }
                return true;
            }
            currentCell = nextCell;
        }
        return true;
    }
1103607
def as_list(self):
        """"""
        return [self.name, self.value, [x.as_list for x in self.children]]
533776
function (list) {
	
	for (var i=0; i < list.length; i++) {
		for (var j=0; j < l_entries.length; j++) {
			if (list[i] === l_entries[j]) {
				l_entries.splice(j, 1);
				break;
			}
		}	
	}
}
17245
private static Map<?, ?> mapOfEntries( Entry<?, ?>... entries ) {
        Map<Object, Object> looseTypedMap = new LinkedHashMap<>( entries.length );
        for (Entry<?, ?> entry : entries)
            looseTypedMap.put(entry.getKey(), entry.getValue());
        return looseTypedMap;
    }
889380
private <E> void listSwap(E[] list, int a, int b) {
		final E tmp = list[a];
		list[a] = list[b];
		list[b] = tmp;
	}
76416
def all_entries(self):
        
        entries = []
        for c in self._all_comp:
            for e in self._all_entries:
                if e.composition.reduced_formula == c.reduced_formula:
                    entries.append(e)
                    break
        return entries
965789
def list(self, node, elem, module, path):
        """"""
        nel, newm, path = self.sample_element(node, elem, module, path)
        if path is None:
            return
        for kn in node.i_key:
            self.node_handler.get(kn.keyword, self.ignore)(
                kn, nel, newm, path)
        self.process_children(node, nel, newm, path, node.i_key)
        minel = node.search_one("min-elements")
        self.add_copies(node, elem, nel, minel)
        if self.annots:
            self.list_comment(node, nel, minel)
429791
def entries(self):
        """"""
        def add(x, y):
            return x + y
        try:
            return reduce(add, list(self.cache.values()))
        except:
            return []
997716
public List<ElementType> toList() {
        List<ElementType> result = new ArrayList<ElementType>(size());
        for (ElementType e : this) result.add(e);
        return result;
    }
1356711
public Entry<T>[] entries() {
        @SuppressWarnings("unchecked")
        Entry<T>[] entries = new Entry[size];
        int idx = 0;
        for (Entry entry : table) {
            while (entry != null) {
                entries[idx++] = entry;
                entry = entry.next;
            }
        }
        return entries;
    }
1207147
def members_entries(self, all_are_optional: bool=False) -> List[Tuple[str, str]]:
        
        rval = []
        if self._members:
            for member in self._members:
                rval += member.members_entries(all_are_optional)
        elif self._choices:
            for choice in self._choices:
                rval += self._context.reference(choice).members_entries(True)
        else:
            return []
        return rval
716285
def as_list(self, fs_type=None):
        """"""
        entries = self._entries
        if fs_type:
            entries = filter(lambda a: a.fs_type == fs_type, entries)
        return entries
74139
def build_list(self):
        """"""
        ret = []
        for p in self.args.stdout.split(','):
            if '.' in p:
                p, a = p.split('.')
            else:
                a = None
            ret.append((p, a))
        return ret
1330427
private void init( List<T> list ) {
		this.list = list;
		indexes = new int[ list.size() ];
		counters = new int[ list.size() ];

		for( int i = 0; i < indexes.length ; i++ ) {
			counters[i] = indexes[i] = i;
		}

		total = 1;
		for( int i = 2; i <= indexes.length ; i++ ) {
			total *= i;
		}

		permutation = 0;
	}
622685
public static <T> List<T> toList(Iterable<T> iterable) {
        List<T> list = null;

        if (iterable != null) {
            list = new ArrayList<>();
            for (T elem : iterable) {
                list.add(elem);
            }
        }

        return list;
    }
679488
def p_simple_list(p):
    ''''''
    tok = p.lexer
    heredoc.gatherheredocuments(tok)

    if len(p) == 3 or len(p[1]) > 1:
        parts = p[1]
        if len(p) == 3:
            parts.append(ast.node(kind='operator', op=p[2], pos=p.lexspan(2)))
        p[0] = ast.node(kind='list', parts=parts, pos=_partsspan(parts))
    else:
        assert len(p[1]) == 1
        p[0] = p[1][0]

    if (len(p) == 2 and p.lexer._parserstate & flags.parser.CMDSUBST and
            p.lexer._current_token.nopos() == p.lexer._shell_eof_token):
        # accept the input
        p.accept()