A specific, existing tag can be deleted by making a DELETE request
on the URL for that tag.

Returns an empty data record.

@param  tag The tag to delete.
@return response
721
public function delete($tag, $params = array(), $options = array())
    {
        $path = sprintf("/tags/%s", $tag);
        return $this->client->delete($path, $params, $options);
    }
1191801
public function deleteByTags($tag)
    {
        if (!isset($this->tags[$tag])) {
            return false;
        }

        foreach ($this->tags[$tag] as $key) {
            $this->delete($key);
        }

        return true;
    }
707577
public function destroy(Tag $tag)
    {
        $deleted = $this->repository->delete($tag);

        return response()->json([
            'error' => !$deleted,
        ]);
    }
486006
public function deleteMatchingTag($tag)
    {
        $this->collection->batchDelete(function (\Sokil\Mongo\Expression $e) use ($tag) {
            return $e->where(Cache::FIELD_NAME_TAGS, $tag);
        });
        
        return $this;
    }
998601
public function delete(TagRequest $request, $type)
    {
        try {
            $ids = hashids_decode($request->input('ids'));

            if ($type == 'purge') {
                $this->repository->purge($ids);
            } else {
                $this->repository->delete($ids);
            }

            return $this->response->message(trans('messages.success.deleted', ['Module' => trans('news::tag.name')]))
                ->status("success")
                ->code(202)
                ->url(guard_url('news/tag'))
                ->redirect();

        } catch (Exception $e) {

            return $this->response->message($e->getMessage())
                ->status("error")
                ->code(400)
                ->url(guard_url('/news/tag'))
                ->redirect();
        }

    }
130678
public Observable<ServiceResponse<Void>> deleteValueWithServiceResponseAsync(String tagName, String tagValue) {
        if (tagName == null) {
            throw new IllegalArgumentException("Parameter tagName is required and cannot be null.");
        }
        if (tagValue == null) {
            throw new IllegalArgumentException("Parameter tagValue is required and cannot be null.");
        }
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        if (this.client.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiVersion() is required and cannot be null.");
        }
        return service.deleteValue(tagName, tagValue, this.client.subscriptionId(), this.client.apiVersion(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteValueDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1228054
public boolean removeDividerByTag(Object tag) {
        if (tag == null) return false;
        for (int k = 0; k < list.getWidgetCount(); k++) {
            Widget w = list.getWidget(k);
            if (isDivider(w) && tag.equals(((JQMListDivider) w).getTag())) {
                list.remove(k);
                items.remove(k);
                return true;
            }
        }
        return false;
    }
1327596
def delete_tag(tag)
      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
      @delete[tag] = true
    end
689787
public <R extends Request<T>> R setTag(Object tag) {
        checkIfActive();
        this.tag = tag;
        return (R) this;
    }
127090
public void removeTaggedComponent(final String tag) {
		TemplateModel model = getOrCreateComponentModel();
		if (model.taggedComponents != null) {
			WComponent component = model.taggedComponents.remove(tag);
			if (model.taggedComponents.isEmpty()) {
				model.taggedComponents = null;
			}
			if (component != null) {
				remove(component);
			}
		}
	}
872408
@SuppressWarnings("unchecked")
    public T addTag(String tag) {
        if (this.tags_ == null) {
            tags_ = new ArrayList<>();
        }
        this.tags_.add(tag);
        return (T) this;
    }
10342
public static <T> GenericResponseBuilder<T> notModified(EntityTag tag) {
    return GenericResponses.<T>notModified().tag(tag);
  }
1164544
public void setTagsToDelete(java.util.Collection<String> tagsToDelete) {
        if (tagsToDelete == null) {
            this.tagsToDelete = null;
            return;
        }

        this.tagsToDelete = new com.amazonaws.internal.SdkInternalList<String>(tagsToDelete);
    }
171865
def delete(request, obj_id=None):
    
    res = Result()

    if obj_id:
        # -- Delete the tag itself
        tag = Tag.objects.get(pk=obj_id)
        guids = []
        images = Image.objects.filter(tags__id=obj_id)
        guids += [_.guid for _ in images]
        videos = Video.objects.filter(tags__id=obj_id)
        guids += [_.guid for _ in videos]
        # -- Remove all tags from objects
        _manageTags([tag.id], guids, add=False)
        # -- Delete old tags
        tag.delete()
    else:
        tags = [_ for _ in request.DELETE.get('tags', '').split(',') if _]
        guids = [_ for _ in request.DELETE.get('guids', '').split(',') if _]

        _manageTags(tags, guids, add=False)

    return JsonResponse(res.asDict())
375703
def delete_tag(project_id, tag_id, custom_headers:nil)
      response = delete_tag_async(project_id, tag_id, custom_headers:custom_headers).value!
      nil
    end
1237971
@Override
	public void deleteTagsForHistoryID (long historyId) throws DatabaseException {
    	SqlPreparedStatementWrapper psDeleteTagsForHistoryId = null;
        try {
        	psDeleteTagsForHistoryId = DbSQL.getSingleton().getPreparedStatement("tag.ps.deletetagsforhid");
			psDeleteTagsForHistoryId.getPs().setLong(1, historyId);
			psDeleteTagsForHistoryId.getPs().execute();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		} finally {
			DbSQL.getSingleton().releasePreparedStatement(psDeleteTagsForHistoryId);
		}
    }
593917
async def delete_tag(self, tag):
        
        path = '/api/tags/{tag}.{ext}'.format(tag=tag, ext=self.format)
        params = {'access_token': self.token}
        return await self.query(path, "delete", **params)