Recall the Taboo list from brain
435780
function loadList(brain) {
    const taboolist = brain.get("taboo");
    if (taboolist != null) {
      for (let topic of taboolist) {
        taboo.set(topic, new RegExp(`\\b${topic}\\b`, "i"));
      }
    }
  }
1021656
def filter_input(self, forced=False, context=None):
    
    content = []
    for hunk in self.hunks(forced, context=context):
        content.append(hunk)
    return content
728965
def get_list(self, name):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        return self._map[normalized_name]
1331065
def _checkObjectToInfer(self, sensationList):
    
    for sensations in sensationList:
      if set(sensations.keys()) != set(range(self.numColumns)):
        raise ValueError(
          "Invalid number of cortical column sensations sent to experiment"
        )
      for pair in sensations.values():
        if not isinstance(pair, tuple) or len(pair) != 2 or \
                not isinstance(pair[0], set) or \
                not isinstance(pair[1], set):
          raise ValueError("Invalid SDR's sent to experiment")
359223
def show_list(self, the_list, cur_p=''):
        '''
        
        '''

        current_page_num = int(cur_p) if cur_p else 1
        current_page_num = 1 if current_page_num < 1 else current_page_num

        num_of_cat = MCollect.count_of_user(self.userinfo.uid)
        page_num = int(num_of_cat / CMS_CFG['list_num']) + 1

        kwd = {'current_page': current_page_num}

        self.render('misc/collect/list.html',
                    recs_collect=MCollect.query_pager_by_all(self.userinfo.uid,
                                                             current_page_num).objects(),
                    pager=tools.gen_pager_purecss('/collect/{0}'.format(the_list),
                                                  page_num,
                                                  current_page_num),
                    userinfo=self.userinfo,

                    cfg=CMS_CFG,
                    kwd=kwd)
309916
def _private_notes(self, key, value):
    """"""
    return [
        {
            'source': value.get('9'),
            'value': _private_note,
        } for _private_note in force_list(value.get('x'))
    ]
534159
def lazy_list_handle(tokens):
    """"""
    if len(tokens) == 0:
        return "_coconut.iter(())"
    else:
        return (
            "(%s() for %s in (" % (func_var, func_var)
            + "lambda: " + ", lambda: ".join(tokens) + ("," if len(tokens) == 1 else "") + "))"
        )
902720
def p_fromitem_list(self,t):
    
    if len(t)==2: t[0] = [t[1]]
    elif len(t)==4: t[0] = t[1] + [t[3]]
    else: raise NotImplementedError('unk_len', len(t)) # pragma: no cover
1071730
def raw_channel_mentions(self):
        
        return [int(x) for x in re.findall(r'<#([0-9]+)>', self.content)]
172061
function deleteTopic(res, topic) {
    const keyTopic = topic.toLowerCase();
    if (taboo.delete(keyTopic)) {
      res.reply(capitalize(`${topic} is no longer taboo`));
      saveList(res.robot.brain);
    } else {
      res.reply(`Oops, ${topic} is not taboo`);
    }
  }
634461
def get_list(self, name: str) -> List[str]:
        """"""
        norm_name = _normalized_headers[name]
        return self._as_list.get(norm_name, [])
675785
def p_CommentOrEmptyLineList(p):
    '''
     
    '''
    if len(p) <= 1:
        p[0] = CommentOrEmptyLineList(None, None)
    elif len(p) <= 2:
        p[0] = CommentOrEmptyLineList(None, p[1])
    else:
        p[0] = CommentOrEmptyLineList(p[1], p[2])
984187
function onList() {
    getCurrentRegistry(function(cur) {
        var info = [''];
        var allRegistries = getAllRegistry();

        Object.keys(allRegistries).forEach(function(key) {
            var item = allRegistries[key];
            var prefix = item.registry === cur ? '* ' : '  ';
            info.push(prefix + key + line(key, 12) + item.registry);
        });

        info.push('');
        printMsg(info);
    });
}
724203
def p_namelist(self,t):
    ""
    if len(t)==2: t[0] = [t[1]]
    elif len(t)==4: t[0] = t[1] + [t[3]]
    else: raise NotImplementedError('unk_len',len(t)) # pragma: no cover
1197538
def thread2list(frame):
    
    l = []
    while frame:
        l.insert(0, frame2string(frame))
        frame = frame.f_back
    return l
1322849
def get_list_representation(self):
        """"""
        if self.is_list:
            return self.list_or_slice
        else:
            return self[list(range(self.num_examples))]
554509
def visit_list(self, node):
        """"""
        return "[%s]" % ", ".join(child.accept(self) for child in node.elts)