• AQ = aqtools /done/
• AT = AsserTcl /done/
• EL = ExtraL /done/
• JT = jultaf /done/
• Opt = Opt package in Tcl --- waiting for inclusion
• PB = Pool_Base /done/
• Tcl = Tcl standard distribution
• TclX = TclX /done/
• s::l = struct::list

(EL)

oneof element list

(TclX)

lcontain list element

(Tcl 8.5)

tcl::mathop::in element list or expr { element in list }

        Determine if the element is a list element of list. If the
        element is contained in the list, 1 is returned, otherwise,
        0 is returned.

        returns the union of the lists

        Procedure to return the logical union of the two specified lists.
        Any duplicate elements are removed.

        returns the common elements of the lists.

        Procedure to return the logical intersection of two lists.
        The returned list will be sorted.

        returns the elements that are not shared between both lists

        Procedure to intersects two lists, returning a list containing
        three lists: The first list returned is everything in lista that
        wasn't in listb. The second list contains the intersection of
        the two lists, and the third list contains all the elements
        that were in listb but weren't in lista. The returned lists
        will be sorted.

        Determine if the specified list is empty. If empty, 1 is
        returned, otherwise, 0 is returned. This command is an
        alternative to comparing a list to an empty string, however
        it checks for a string of all whitespaces, which is an empty
        list.

        Sets value of the variables specified by the NAME arguments to
        that of the existing elements of LIST. Returns remaining list
        elements. If the number of variables exceeds the list length,
        the remaining variables will be removed.

(PB)

::pool::list::assign varList list

(Tcl 8.x)

foreach varList list break

        By Brent Welch. Assigns a set of variables from a list of values.
        If there are more values than variables, they are ignored. If
        there are fewer values than variables, the variables get the empty
        string.

(TclX, Tcl8.5)

lassign list var ?var ...?

        Assign successive elements of a list to specified variables.
        If there are more variable names than fields, the remaining
        variables are set to the empty string. If there are more
        elements than variables, a list of the unassigned elements
        is returned.

        For example,

                lassign {dave 100 200 {Dave Foo}} name uid gid longName

        Assigns name to ``dave'', uid to ``100'', gid to ``200'', and
        longName to ``Dave Foo''.

(EL)

lfind mode list pattern

(TclX)

lmatch ?mode? list pattern

        Search the elements of list, returning a list of all elements
        matching pattern. If none match, an empty list is returned.

        The mode argument indicates how the elements of the list are
        to be matched against pattern and it must have one of the
        following values:

        -exact  The list element must contain exactly the same string
                as pattern.

        -glob   Pattern is a glob-style pattern which is matched against
                each list element using the same rules as the string
                match command.

        -regexp Pattern is treated as a regular expression and matched
                against each list element using the same rules as the
                regexp command.

        If mode is omitted then it defaults to -glob.

(JT)

Juf::Sequence::match PATTERN LIST

        Returns a new list with all elements of LIST matching PATTERN
        as with string match. == glob '''!'''

(PB)

::pool::list::match list pattern

(Tcl 8.5)

lsearch -all -inline list pattern

        All words not contained in list pattern are removed from list.
        In set-notation: result = intersect (list, pattern). This is
        not completely true, duplicate entries in 'list' remain in the
        result, given that they appear at all.

(PB)

::pool::list::filter list pattern

(Tcl 8.5)

lsearch -all -inline -not list pattern

        All words contained in the list pattern are removed from list.
        In set-notation: result = list - pattern. Returns the set
        difference of list and pattern. '''Negative match'''.

        returns a list with all items in list1 that are not in list2. with
        the -sorted option the command will usually be a lot faster, but
        both given lists must be sorted with lsort; The optional $var give
        the name of a variable in which the removed items will be stored.

        returns a list in which all duplactes are removed. with the
        -sorted option the command will usually be a lot faster,
        but $list must be sorted with lsort; The optional $var gives
        the name of a variable in which the removed items will be stored.

        Procedure to remove duplicate elements from a list. The returned
        list will be sorted.

        Removes duplicate entries from list. Returns the modified list.

        adds the items to the list if not already there

        Works like the Tcl builtin lappend, but considers these options:

        -nonempty       Append only non-empty values.
        --              Marks the end of the options. The argument
                        following this one will be treated as NAME
                        even if it starts with a -.

        This command treats each string argument as a list and concatenates
        them to the end of the contents of var, forming a a single list.
        The list is stored back into var and also returned as the result.
        if var does not exist, it is created.

        Removes the last element of the list contained in variable listVar.
        Returns the last element of the list, or {} in case of an empty list.

        Removes COUNT element from the end of the list stored in the
        variable NAME and returns the last element removed. COUNT
        defaults to 1.

        returns the last element from a list, thereby removing it from
        the list. If pos is given it will return the pos element of the
        list.

        Removes COUNT element from the list stored in the variable NAME
        and returns the last element removed. COUNT defaults to 1.

        returns the first element from a list, thereby removing it from
        the list.

        The list stored in the variable listVar is shifted down by one.
        Returns the first element of the list stored in listVar, or {}
        for an empty list. The latter is not a sure signal, as the list
        may contain empty elements.

        Removes the item at position from the list stored in variable
        listVar.

        Removes the item at position from the list stored in variable
        listVar and inserts newItem in its place. Returns the changed list.

        The lvarpop command pops (deletes) the element indexed by the
        expression indexExpr from the list contained in the variable var.
        If index is omitted, then 0 is assumed. If string, is specified,
        then the deleted element is replaced by string. The replaced or
        deleted element is returned. Thus ``lvarpop argv 0'' returns the
        first element of argv, setting argv to contain the remainder of the
        string.

        If the expression indexExpr starts with the string end, then end
        is replaced with the index of the last element in the list. If the
        expression starts with len, then len is replaced with the length
        of the list.

        The same as 'lappend', provided for symmetry only.

        opposite of lpop.

        opposite of lshift: prepends ?item? to the list.

(PB)

::pool::list::prepend listVar newElement

(PB)

::pool::list::unshift listVar newElement

        The list stored in the variable listVar is shifted up by one.
        newElement is inserted afterward into the now open head position.

        The lvarpush command pushes (inserts) string as an element in the
        list contained in the variable var. The element is inserted before
        position indexExpr in the list. If index is omitted, then 0 is
        assumed. If var does not exists, it is created.

        If the expression indexExpr starts with the string end, then end
        is replaced with the index of the last element in the list. If
        the expression starts with len, then len is replaced with the
        length of the list. Note the a value of end means insert the
        string before the last element.

        Returns the first element of list.

        Returns the last element of list.

        Returns everything before the last element of list.

        Returns everything behind the first element of list.

        removes the items from the list

        By Brent Welch. Deletes an item from the list stored in
        listVar, by value. Returns 1 if the item was present, else 0.

        create a sublist from a set of indices. When -exclude is specified,
        the elements of which the indexes are not in the list will be given.
        eg.:

        % lsub {Ape Ball Field {Antwerp city} Egg} {0 3}
        Ape {Antwerp city}
        % lsub {Ape Ball Field {Antwerp city} Egg} -exclude {0 3}
        Ball Field Egg

        Idea from a thread in c.l.t.
        General permutation / selection of list elements. Takes the elements
        of list whose indices were given to the command and returns a new list
        containing them, in the specified order.

        gives the positions of the elements in list in the reference list.
        If an element is not found in the reference list, it returns -1.
        Elements are matched only once. eg.:

        % lcor {a b c d e f} {d b}
        3 1
        % lcor {a b c d e f} {b d d}
        1 3 -1

        merges two lists into one eg.:

        % lmerge {a b c} {1 2 3}
        a 1 b 2 c 3
        % lmerge {a b c d} {1 2} 2
        a b 1 c d 2

        unmerges items from a list to the result; the remaining items are
        stored in the given variable ?var? eg.:

        % lunmerge {a 1 b 2 c 3}
        a b c
        % lunmerge {a b 1 c d 2} 2 var
        a b c d
        % set var
        1 2

        sets all elements of the list at the given indices to value ?item?

        sets the values of valuelist to the respective elements in varlist
        for the given array.

        does a regsub for each element in the list, and returns the resulting
        list. eg.:

        % lregsub {c$} {afdsg asdc sfgh {dfgh shgfc} dfhg} {!}
        afdsg asd! sfgh {dfgh shgf!} dfhg
        % lregsub {^([^.]+)\.([^.]+)$} {start.sh help.ps h.sh} {\2 \1}
        {sh start} {ps help} {sh h}

        Returns the reversed list.

        Treats list as list of lists and extracts the column'th element of
        each list item. If list is seen as matrix, then the procedure
        returns the data of the specified column.

        Applies cmd to all entries of list and concatenates the
        individual results into a single list. The cmd must accept exactly
        one argument, which will be the current element.

        Determines the length of the longest entry contained in the list.

        List universal quantifier: evaluates expr for all items or item sequences,
        and returns 1 if the expresson is true over the whole list, and 0 otherwise

        List existential quantifier: evaluates expr for all items or item sequences,
        and returns 1 if the expresson is true for any item in the list, and 0 otherwise

        find the longest common initial string in a list

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References