unalias name
        Delete the specified alias.
181707
def do_unalias(self, arg):
        
        args = arg.split()
        if len(args) == 0: return
        if args[0] in self.aliases:
            del self.aliases[args[0]]
351663
public static function unsetAlias()
    {
        $file = file_get_contents(self::$aliasFilePath);

        $aliasString = str_replace(
            "'".self::$bowerVendor."'",  
            "'".self::$sourceBower."'",
            self::$aliasBowerString
            );

        $file = str_replace(
            $aliasString, 
            self::$aliasBowerString, 
            $file
            );

        $result = file_put_contents(self::$aliasFilePath, $file);

        if ($result) {
            
            echo "Uninstall alias @bower done\n";
        }
    }
1063597
public function unregisterSubCommandAlias($alias)
    {
        if (! array_key_exists($alias, $this->subCommandAliases)) {
            throw new \Exception("A sub-command alias with the name {$alias} does not exist.");
        }

        unset($this->subCommandAliases[$alias]);
    }
630214
def del_character(self, name):
        
        self.query.del_character(name)
        self.del_graph(name)
        del self.character[name]
746465
def delete(name)
      name = normalize_header name.to_s
      @pile.delete_if { |k, _| k == name }
    end
357430
def remove_named_query(self, alias, afterwards=None):
        
        if self.ro:
            raise DatabaseROError()
        self.writequeue.append(('setconfig', afterwards, 'query.' + alias, ''))
845494
protected function reduceAlias($name)
    {
        $aliases = $this->dumper->getAliases();

        if (isset($aliases[$name])) {
            return $this->reduceAlias($aliases[$name]);
        }

        return $name;
    }
364041
async def delete(self, *names):
        
        count = 0

        for arg in names:
            count += await self.execute_command('DEL', arg)

        return count
1315192
public function removeAlias($alias)
    {
        if (isset($this->aliasDefinitions[$alias = (string) $alias])) {
            unset($this->aliasDefinitions[$alias]);
            $this->removedIds[$alias] = true;
        }
    }
414383
def delete(self, name):
    '''
    
    '''
    keys = self._client.keys('%s%s:*'%(self._prefix,name))

    pipe = self._client.pipeline(transaction=False)
    for key in keys:
      pipe.delete( key )
    pipe.execute()

    # Could be not technically the exact number of keys deleted, but is a close
    # enough approximation
    return len(keys)
1111988
def delete(alias_value, platform = nil)
      params = platform.nil? ? nil : { platform: build_platform(platform) }
      url = base_url + alias_value
      Http::Client.delete(@jpush, url, params: params)
    end
720669
public void delete()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "delete");
        //Tell the target of the alias to remove the backwards reference to it
        _targetDestinationHandler.removeTargettingAlias(this);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "delete");
    }
1219077
def remove(alias_name, options)
      file = File.open(FILE_PATH, 'r')
      servers = all_hosts_in(file)
      if servers.include?alias_name
        new_file = File.open(FILE_PATH + 'temp', 'w')
        remove_alias_name(alias_name, file, new_file)

        File.delete(FILE_PATH)
        File.rename(FILE_PATH + 'temp', FILE_PATH)
        # Causes a bug in fedore if permission was not updated to 0600
        File.chmod(0600, FILE_PATH)
        PRINTER.print "`#{alias_name}` was successfully removed from your hosts"
      else
        PRINTER.print "Could not find host `#{alias_name}`"
      end
      finish_exec
    end
716223
public function removeAlias($alias)
    {
        $this->validateAlias($alias);
        if (!$this->aliases->has($alias)) {
            throw new Exception\AliasNotFoundException(sprintf('The "%s" item alias does not exist.', $alias));
        }

        $this->aliases->remove($alias);
    }
94147
protected function deleteUnassignedAbilities()
    {
        $query = $this->getUnassignedAbilitiesQuery();

        if (($count = $query->count()) > 0) {
            $query->delete();

            $this->info("Deleted {$count} unassigned ".Str::plural('ability', $count).'.');
        } else {
            $this->info('No unassigned abilities.');
        }
    }
904667
public function removeAlias($alias = null)
    {
        return (new AuthorizationBuilder(TransactionType::ALIAS, $this))
            ->withAlias(AliasAction::DELETE, $alias);
    }
1357908
protected function removeAliasFor($key)
    {
        $aliases = \array_keys($this->aliases, $key);

        if (!empty($aliases)) {
            foreach ($aliases as $alias) {
                unset($this->aliases[$alias]);
            }
        }
    }