Makes a HTML list from the given iterable

    :param items: The items to list
    :param tag: The tag to use (ul or ol)
    :return: The HTML list code
174410
def make_html_list(items, tag="ul"):
    # type: (Iterable[Any], str) -> str
    
    html_list = "\n".join(
        '<li><a href="{0}">{0}</a></li>'.format(item) for item in items
    )
    return "<{0}>\n{1}\n</{0}>".format(tag, html_list)
1292586
public static function inlineList($items, $htmlOptions = array())
    {
        $listItems = array();
        Html::addCssClass($htmlOptions, 'inline-list');
        foreach ($items as $item) {
            $listItems[] = \CHtml::tag('li', $htmlOptions, $item);
        }

        if (!empty($listItems)) {
            return \CHtml::tag('ul', $htmlOptions, implode("\n", $listItems));
        }
    }
132104
def to_list(item_or_list):
    
    if isinstance(item_or_list, list):
        return item_or_list
    elif isinstance(item_or_list, (str, bytes)):
        return [item_or_list]
    elif isinstance(item_or_list, Iterable):
        return list(item_or_list)
    else:
        return [item_or_list]
91142
public static function listy($items, $attribs = array(), $type = 'ul')
    {
        if (!Arr::iterable($items)) {
            return '';
        }
        
        $htmls = array();
        $htmls[] = '<' . $type . self::attribs($attribs) . '>';
        foreach ($items as $item) {
            $htmls[] = '<li>' . $item . '</li>';
        }
        $htmls[] = '</' . $type . '>';
        return join("\n", $htmls);
    }
611234
public static BasicTagList copyOf(Iterable<String> tags) {
    SmallTagMap.Builder builder = SmallTagMap.builder();
    for (String tag : tags) {
      builder.add(Tags.parseTag(tag));
    }
    return new BasicTagList(builder.result());
  }
1113151
def list2html(lst):
    
    txt = '<TABLE width=100% border=0>'
    for l in lst:
        txt += '<TR>\n'
        if type(l) is str:
            txt+= '<TD>' + l + '</TD>\n'
        elif type(l) is list:
            txt+= '<TD>'
            for i in l:
                txt += i + ', '
            txt+= '</TD>'
        else:
            txt+= '<TD>' + str(l) + '</TD>\n'
        txt += '</TR>\n'
    txt += '</TABLE><BR>\n'
    return txt
571197
def list_tags(self, pattern=None):
        
        request_url = "{}tags".format(self.create_basic_url())

        params = None
        if pattern:
            params = {'pattern': pattern}

        return_value = self._call_api(request_url, params=params)
        return return_value['tags']
216563
def tag_del(self, item, tag):
        
        tags = list(self.item(item, "tags"))
        if tag in tags:
            tags.remove(tag)
            self.item(item, tags=tuple(tags))
1326827
def as_select(self, _items=None, **kwargs):
        
        attrs = self.extra.copy()
        attrs.update(kwargs)
        attrs['name'] = self.name
        if not self.optional:
            attrs['required'] = True
        html = [u'<select %s>' % get_html_attrs(attrs)]
        values = [self.to_string(**attrs)] or []
        items = _items or self.items

        for item in items:
            if isinstance(item, list):
                html.extend(self._render_optgroup(item, values))
            else:
                html.append(self._render_option(item, values))
        html.append(u'</select>')

        return Markup('\n'.join(html))
775731
def create_html_from_fragment(tag):
    

    try:
        assert isinstance(tag, bs4.element.Tag)
    except AssertionError:
        raise TypeError
    try:
        assert tag.find_all('body') == []
    except AssertionError:
        raise ValueError

    soup = BeautifulSoup('<html><head></head><body></body></html>', 'html.parser')
    soup.body.append(tag)
    return soup
282486
def _render_list(self, items, empty='<pre>&lt;empty&gt;</pre>'):
    
    if not items or len(items) == 0:
      self._segments.append(empty)
      return
    self._segments.append('<ul>')
    for o in items:
      self._segments.append('<li>')
      self._segments.append(str(o))
      self._segments.append('</li>')
    self._segments.append('</ul>')
571569
def htmlize_list(items):
    
    out = ["<ul>"]
    for item in items:
        out.append("<li>" + htmlize(item) + "</li>")
    out.append("</ul>")
    return "\n".join(out)
625338
def append(self, tag):
        '''
            
        '''
        list.append(self, tag)
        self.uids.add(tag.uid)
1222440
def html_factory(tag, **defaults):
    '''

    '''
    def html_input(*children, **params):
        p = defaults.copy()
        p.update(params)
        return Html(tag, *children, **p)
    return html_input
793709
def get_taglist(node):
    
    return [re.sub(r'\{[^}]*\}', "", copy(subnode.tag))
            for subnode in node.nodes]
1301696
def tag_toggle(self, *tags):
        
        return View({**self.spec, 'tag': list(set(self.tags) ^ set(tags))})
15875
def tags(name = nil)
      list = stable_sort_by(@tags + convert_ref_tags, &:tag_name)
      return list unless name
      list.select {|tag| tag.tag_name.to_s == name.to_s }
    end