Removes a symbol from the array of symbols.
It is recommended to only remove custom symbols
(that have been added via the addSymbol() method)

@param AbstractSymbol $symbol
@return void
12138
public function remove(AbstractSymbol $symbol)
    {
        if (! in_array($symbol, $this->symbols)) {
            throw new \InvalidArgumentException('Error: Cannot remove symbol, because it is unknown');
        }

        unset($this->symbols[get_class($symbol)]);

        $this->validate();
    }
238007
public function removeSignal($signal)
    {
        if (isset($this->_signalEvents[$signal])) {
            $event = $this->_signalEvents[$signal];
            event_del($event);
            unset($this->_signalEvents[$signal]);
        }
    }
1302955
public function remove(string ...$tokens)
    {
        if (count($tokens) === 0) {
            return;
        }
        if (count($this->tokens) === 0) {
            return;
        }
        foreach ($tokens as $t) {
            $i = array_search($t, $this->tokens);
            if ($i === false) {
                continue;
            }
            array_splice($this->tokens, $i, 1);
        }
        $this->setAttributeValue();
    }
353635
public function setCurrentPlayer($symbol)
    {
        $this->checkSymbol($symbol);

        if (TicTacToe::X === $symbol) {
            $this->lastMove = TicTacToe::O;
        }

        if (TicTacToe::O === $symbol) {
            $this->lastMove = TicTacToe::X;
        }

        return $this;
    }
762399
public function removeAttribute(string $key): void
    {
        $this->tag->removeAttribute($key);

        //clear any cache
        $this->clear();
    }
1175293
public function removeJugglable($attributes)
    {
        // Make sure we are dealing an associative array
        if ( ! is_array($attributes)) {
            $attributes = func_get_args();
        }
        $attributes = array_flip($attributes);

        // Get the remaining jugglables
        $jugglables = array_diff_key($this->getJugglable(), $attributes);

        // Set the remaining jugglables
        $this->setJugglable($jugglables);
    }
445166
public static function useCurrency(string $currency, ?string $symbol = null): void
    {
        static::$currency = $currency;
        static::useCurrencySymbol($symbol ?: static::guessCurrencySymbol($currency));
    }
229375
function getReplacement($symbol) {
    return isset($this->symbol_replacements[$symbol]) ? $this->symbol_replacements[$symbol] : $symbol;
  }
370427
public function remove($enumerator): void
    {
        $ord = ($this->enumeration)::get($enumerator)->getOrdinal();
        unset($this->map[$ord]);
    }
518573
public function remove($name)
    {
        $this->requireNames();
        
        $lower = strtolower($name);
        if(array_key_exists($lower, $this->names)) {
            $name = $this->names[$lower];
            unset($this->names[$lower]);
            unset($this->headers[$name]);
        }
    }
1115769
public function remove($entity)
    {
        if ($this->evm->hasListeners(Events::preRemove)) {
            $this->evm->dispatchEvent(Events::preRemove, new Event\LifecycleEventArgs($entity, $this->sm));
        }

        $oid = spl_object_hash($entity);
        $this->scheduledForDelete[$oid] = $entity;

        if ($this->evm->hasListeners(Events::postRemove)) {
            $this->evm->dispatchEvent(Events::postRemove, new Event\LifecycleEventArgs($entity, $this->sm));
        }
    }
790708
def clear_symbols(self, index):
        """"""
        try:
            del self.table[index:]
        except Exception:
            self.error()
        self.table_len = len(self.table)
1071608
public static function useCurrency($currency, $symbol = null)
    {
        static::$currency = $currency;

        static::useCurrencySymbol($symbol ?: static::guessCurrencySymbol($currency));
    }
305637
function addSymbol (s) {
        if (s && !symbols_[s]) {
            symbols_[s] = ++symbolId;
            symbols.push(s);
        }
    }
1070356
public void expandSymbol(int symbol) {
        int prod, maxProd;
        int ofs, maxOfs;
        int ofs2, maxOfs2;
        int i, j;
        boolean found;
        int count, nextCount;
        IntArrayList next;
        int[][] expand;
        List<int[]> expandLst;
        int right;

        maxProd = getProductionCount();

        // make an array of the expand prods to easily index them;
        // storing the indexes instead is difficult because the indexes
        // max change
        expandLst = new ArrayList<int[]>();
        for (prod = 0; prod < maxProd; prod++) {
            if (getLeft(prod) == symbol) {
                expandLst.add(getProduction(prod));
            }
        }
        expand = new int[expandLst.size()][];
        expandLst.toArray(expand);

        for (prod = maxProd - 1; prod >= 0; prod--) {
            maxOfs = getLength(prod);
            found = false;
            nextCount = 1;
            for (ofs = 0; ofs < maxOfs; ofs++) {
                if (getRight(prod, ofs) == symbol) {
                    found = true;
                    nextCount *= expand.length;
                }
            }
            if (found) {
                // testing found is an optimization
                for (i = 0; i < nextCount; i++) {
                    count = i;
                    next = new IntArrayList();
                    next.add(getLeft(prod));
                    for (ofs = 0; ofs < maxOfs; ofs++) {
                        right = getRight(prod, ofs);
                        if (right == symbol) {
                            j = count % expand.length;
                            maxOfs2 = expand[j].length;
                            for (ofs2 = 1; ofs2 < maxOfs2; ofs2++) {
                                next.add(expand[j][ofs2]);
                            }
                            count /= expand.length;
                        } else {
                            next.add(right);
                        }
                    }
                    if (count != 0) {
                        throw new RuntimeException();
                    }
                    addProduction(prod + 1, next.toArray());
                }
                removeProduction(prod);
            }
        }
    }
1175759
public function withFlag($flag): void
    {
        $flag = $this->parseFlag($flag);

        $this->flags = $this->flags | $flag;
    }
544226
public function remove(string $key): void
    {
        if (isset($this->orgData[$key])) {
            if (isset($this->updateAttributes[$key])) {
                unset($this->updateAttributes[$key]);
            }
        } else {
            if (isset($this->addAttributes[$key])) {
                unset($this->addAttributes[$key]);
            }
        }
        $this->removeAttributes[$key] = 0;
    }