Return the last item in this list.
 @return [Object]
436739
def last(allow_improper = false)
      if allow_improper and improper?
        list = self
        list = list.tail while list.tail.kind_of?(Erlang::List)
        return list.tail
      else
        raise Erlang::ImproperListError if improper?
        list = self
        list = list.tail until list.tail.empty?
        return list.head
      end
    end
683375
public function last()
    {
        if ($this->isEmpty()) {
            return $this->makeItem(null);
        }

        $arResultIDList = $this->arElementIDList;

        $iElementID = array_pop($arResultIDList);

        return $this->makeItem($iElementID);
    }
367033
public function last()
    {
        $last = null;
        foreach ($this->each() as $v) {
            $last = $v;
        }
        return $last;
    }
1369401
def last_tag
      tag = ::FFI::MemoryPointer.new(:string)
	  proto = ::FFI::MemoryPointer.new(:int)
      Klass.getLastTag2(@handle, tag, proto)
      strPtr = tag.get_pointer(0)
      strPtr.null? ? nil : strPtr.read_string
	end
1351730
def last(self):
        

        if self.limit > self.total:
            return None
        elif self.offset >= self.total:
            return None
        else:
            offset = (self.total / self.limit) * self.limit
            return {'page[offset]': offset, 'page[limit]': self.limit}
541630
def last(options = nil, &block)
      options = options ? Hash[options] : {}
      options[:what] = :last
      options[:count] ||= 1
      find(options, &block)
    end
836758
public Node getLastChild()
  {

    ElemTemplateElement lastChild = null;

    for (ElemTemplateElement node = m_firstChild; node != null;
            node = node.m_nextSibling)
    {
      lastChild = node;
    }

    return lastChild;
  }
928266
public int last() {
    assertNonEmpty();
    short lastKey = keys[size - 1];
    Container container = values[size - 1];
    return lastKey << 16 | container.last();
  }
896674
def get_last(self, type_, key):
        
        self._check_type(type_)
        with self._lock:
            return self._config[type_]['last'][key]
919969
public function LastItem()
    {
        $pageLength = $this->getPageLength();
        if (!$pageLength) {
            return $this->getTotalItems();
        } elseif ($start = $this->getPageStart()) {
            return min($start + $pageLength, $this->getTotalItems());
        } else {
            return min($pageLength, $this->getTotalItems());
        }
    }
379304
public function last()
    {
        $arr = $this->val();
        $last = end($arr);

        return StdObjectWrapper::returnStdObject($last);
    }
505878
def request
      @last_response = nil
      old_stripe_client = Thread.current[:stripe_client]
      Thread.current[:stripe_client] = self

      begin
        res = yield
        [res, @last_response]
      ensure
        Thread.current[:stripe_client] = old_stripe_client
      end
    end
849673
def indicate_last(items):
    
    last_index = len(items) - 1
    for (i, item) in enumerate(items):
        yield (i == last_index, item)
1250238
def next_item
      return nil unless more_items?
      return response.cursor if response.respond_to?(:cursor)
      response.offset + response.limit
    rescue StandardError
      nil
    end
814165
def get_last(self, num=10):
        
        max_item = self.get_max_item()
        urls = [urljoin(self.item_url, F"{i}.json") for i in range(
            max_item - num + 1, max_item + 1)]
        result = self._run_async(urls=urls)
        return [Item(r) for r in result if r]
581693
def last(self, skipna=None, keep_attrs=None):
        
        return self._first_or_last(duck_array_ops.last, skipna, keep_attrs)
52786
def item_for widget
      each do |e|
        if e.is_a? Item
          if e.widget == widget
            return e
          end
        end
      end
      return nil
    end