When writing LaTeX code, I often successively make changes like adding or removing items. I'd like to have TeX count and update the number of items in the list automatically, as in

There are numItemsNextList ways how a parameter can be given:

begin{itemize}

item By a constant expression.

item By user interaction.

item From another database.

end{itemize}

(what happens next is of course that I realize there is yet another way to give a parameter and add it to the list)

I could roll out my own preprocessor to just count the number of item-commands in the following begin{...} ... end{...} block. But is there a TeX solution as well?

Here's a way: we modify the itemize environment with etoolbox tools; each item command will step a counter; every environment steps another. A couple of LaTeX runs can be necessary for the numbers to stabilize.

documentclass{article}

usepackage{etoolbox,refcount}



newcounter{countitems}

newcounter{nextitemizecount}

newcommand{setupcountitems}{%

  stepcounter{nextitemizecount}%

  setcounter{countitems}{0}%

  pretoitem{stepcounter{countitems}}%

}

makeatletter

newcommand{computecountitems}{%

  edef@currentlabel{numberc@countitems}%

  label{countitems@numbernumexprvalue{nextitemizecount}-1relax}%

}

newcommand{nextitemizecount}{%

  getrefnumber{countitems@numberc@nextitemizecount}%

}

makeatother

AtBeginEnvironment{itemize}{setupcountitems}

AtEndEnvironment{itemize}{computecountitems}



begin{document}



There are nextitemizecount{} ways how a parameter can be given:

begin{itemize}

item By a constant expression.

item By user interaction.

item From another database.

end{itemize}



There are nextitemizecount{} ways how a parameter can be given:

begin{itemize}

item By a constant expression.

item By user interaction.

item From another database.

item Foo.

end{itemize}



The next doesn't count.



begin{itemize}

item A

item B

end{itemize}



There are nextitemizecount{} ways how a parameter can be given:

begin{itemize}

item By a constant expression.

item By user interaction.

end{itemize}



end{document}

I am not sure how to do it with itemize. But with enumerate environment you could add a label to last item.

documentclass{article}



begin{document}

There are ref{lst:num} ways how a parameter can be given:

begin{enumerate}

    item By a constant expression.

    item By user interaction.

    item From another database. 

    label{lst:num}

end{enumerate}



end{document}

With the help of the enumitem package you can define a list based on enumerate, but behaving as itemize as far as labels are concerned. In this way one is allowed to place labels, in particular to the last item. The following example illustrates such definition (for a list environment with four-level nesting) and also shows that the approach works with nesting:

documentclass{article}

usepackage{enumitem}



newlist{citemize}{enumerate}{4}

setlist[citemize,1]{label=$bullet$,ref=arabic*}

setlist[citemize,2]{label=--,ref=arabic*}

setlist[citemize,3]{label=$ast$,ref=arabic*}

setlist[citemize,4]{label=$cdot$,ref=arabic*}



begin{document}



There are~ref{lst:num} ways how a parameter can be given, and user interaction has~ref{lst:subnum} possibilities:

begin{citemize}

  item By a constant expression.

  item By user interaction.

  begin{citemize}

    item First subitem.

    item Second subitem.

    label{lst:subnum}

  end{citemize}

  item From another database. 

  label{lst:num}

end{citemize}



end{document}

The following code provides a redefined itemize environment.

Update

An answer that suits your request a little better …
items are labelable if you use the option "Lableable Items" (item[<opt>]label{<key>}).

Code

documentclass{article}

usepackage{xspace}         % used in the numItemsNextList command: http://ctan.org/pkg/xparse

newcounter{myItemCounter}          % counts items in the itemize list

newcounter{myInternalLabelCounter} % increments so that every itemize environment gets it own label

letolditemitem               % save original commands: item

letolditemizeitemize         %                         begin{itemize}

letoldenditemizeenditemize   %                         end{itemize}



newififcountitems             % numItemsNextList set countitems true, otherwise no counting occurs



newcommand*numItemsNextList{%

    countitemstrue%                                         initial: set countitems=true

    setcounter{myItemCounter}{0}%                           initial: myItemCounter=0

    stepcounter{myInternalLabelCounter}%                    initial: myInternalLabelCounter++

    ref{myInternalLabelKeyarabic{myInternalLabelCounter}}% needs 2nd run

    xspace%                                                 provides space without the need to use numItemsNextList{}

}

renewenvironment{itemize}{%

  olditemize%

}{%

  ifcountitems% only set label if we count at all

%    addtocounter{myItemCounter}{-1}% Without "Labelable Items": comment out if you have labelable items

%    refstepcounter{myItemCounter}%   Without "Labelable Items": comment out if you have labelable items

    label{myInternalLabelKeyarabic{myInternalLabelCounter}}%

  fi%

  oldenditemize%

  globalcountitemsfalse% sets countitems=false (end of itemize environment)

}

renewcommand*item{%

  ifcountitems%

%  stepcounter{myItemCounter}%     Without "Labelable Items": If you use this comment out next line!

  refstepcounter{myItemCounter} % With "Labelable Items":    If you use this comment out the line above!

  fi%

  olditem%

}



begin{document}

There are numItemsNextList ways how a parameter can be given:

begin{itemize}

item By a constant expression.

item By user interaction.

item From another database.

end{itemize}



Without I:

begin{itemize}

item Not countable.

end{itemize}



There are numItemsNextList ways how a parameter can be given (#ref{lstitm:important} is a good one.):

begin{itemize}

item By a constant expression.

item By user interaction.

itemlabel{lstitm:important} From another database.

item (Not really.)

end{itemize}



Without II:

begin{itemize}

item Not countable.

item Not countable.

end{itemize}

end{document}

Output

Old Solution

This solution can refer to any itemize environment with the optional argument.

Code

documentclass{article}

newcounter{myItemCounter}

letolditemitem

letolditemizeitemize

letoldenditemizeenditemize



makeatletter

newcommand*@empty@string{}

newcommand*count@label{}

renewcommand*item{refstepcounter{myItemCounter}olditem}



renewenvironment{itemize}[1]{%

    setcounter{myItemCounter}{0}%

    renewcommand*count@label{#1}%

    olditemize%

    }{%

    ifxcount@label@empty@stringelse%

        label{count@label}%

    fi%

    oldenditemize%

}

newcommand*{labelitem}[1]{%

    refstepcounter{myItemCounter}label{#1}%

    olditem%

}

makeatother



begin{document}

This list contains ref{lst:ct} item(s), the ref{lst:important}. is important:

begin{itemize}

    item[a] First item.

    labelitem{lst:important}[x] Next item.

    labelitem{lst:ct} Last item?

end{itemize}



This list contains ref{lst:ct2} item(s):

begin{itemize}[lst:ct2]

    item First item.

    item[i] Last item?

end{itemize}

end{document}

Output

The package xcntperchap can do this, with some 'easy' setup, using a dummy track level counter (dummycntr). Since itemize does not use a counter itself, another counter is necessary (for enumerate, it would be much easier, just say RegisterCounters{dummycntr}{enumi} then.

The current version works for the first level of itemize nesting only so far.

documentclass{article}



usepackage{xpatch}

usepackage{xcntperchap}



newcounter{dummycntr}

newcounter{itemi}

RegisterCounters{dummycntr}{itemi}

xpretocmd{item}{stepcounter{itemi}}{}{}

xpretocmd{itemize}{stepcounter{dummycntr}}{}{}





begin{document}

There are ObtainTrackedValue[1]{dummycntr}{itemi} ways how a parameter can be given, but see also that there are 

ObtainTrackedValue[2]{dummycntr}{itemi} other ways: 



begin{itemize}

item By a constant expression.

item By user interaction.

item From another database.

end{itemize}



Other ways:



begin{itemize}

item This

item Is 

item Some

item Other

item Itemization

end{itemize}









end{document}