Author

Andreas Kupries.

• A function to remove one or more items from the end of a list.
• A function to remove one or more items from the front of a list.
• A function to append one or more items at the end of a list. --- This function already exists in the kernel, lappend.
• A function to prepend one or more items before the front of a list.

• Check for an empty list.
• A function to remove an item by position, in place (lreplace in the kernel does that, but not in place!)
• A function to replace an item by another item, in place. (lreplace, in the kernel, can do that too, but not in place)

   Remark:
      TclX combines both of the above in one function, as does the
      kernel. To discuss.

• A function to remove items from a list, by name!
• A function to append new items to a list, as long as they are not already in the list.
• A function to append new items to a list, but only the non-empty ones.
• A function to append complete lists to a list, but not as single items. Their items become items of the modified list too (See 'lvarcat').

   The last three functions could be combined to form a sort of
   generalized lappend, with options controlling the behaviour.

• A function to add an item at an arbitrary place in the list, in place. Sort of generalized stack/queue insertion functionality.
• Lispish access to head item and tail of a list (car, cdr), and the complements, last item and front of a list. Four functions.
• Fast assignment of values in a list to different variables.
• Removal of duplicate items from a list. Sort of list2set conversion.
• Removal of empty items from a list.
• A function to reverse the order of the items in a list.
• A generalized lindex allowing the selection of more than one element, more than once, exclusion of elements, etc.
• Computation of the indices of items in a list, by name. Or pattern ?

   Uses: Scatter/gather operations, permutations.

• A generic function for application of a command to all elements in a list.
• A generic function for application of a command to all elements in a list, with reduction to a single result.

   Both of the above can be used as the base of several other
   nice functionalities (see below).  And they might be usable
   for the implementation of some of the functionality listed above too.

• A function applying a regsub to all elements of a list and returning the results, again as a list.

• A function treating a list as list of lists (a matrix) and returning a specified column of that matrix (items of the outer list are rows). This is a projection operation.
• A function computing the length of the longest item in a list, the items are treated as strings.
• List universal/existential quantifiers: An expression has to hold for all items or item sequences in a list (universal), or for at least one item/item sequence (existential).

• A function extending the known kernel command lsearch to return all matching elements from a list. Allow negation, i.e. returning all non-matching elements ?
• Extend the above to allow multiple patterns.

• A function to merge two or more lists into one, by interleaving the contents. Now to have lazy lists too :-).
• A function to split a single list into two or more. The reverse of the last function.
• A function to set several places in a list to an item, controlled by a list of indices. (Basically the second function in 3., extended to work for multiple items).
• A function to turn a flat list into a nested list by creating a sublist of every n elements where n is known as the stride.
• An option which can be added (in a consistent manner) to list functions that return a flat list to post process the flat list by converting in into a nested list using a stride value. Two candidates for this new option are 'array get' and 'split'.
• See Counting Elements in a List.

     set myList [lreplace $myList 20 20 "new Element"]

     replace-in-place myList 20 20 "new Element"

(f o g) x

The function composition combinator. Equivalent to doing f(g x)

I x

The identity combinator. Equivalent to x

K x y

The constant function combinator. Equivalent to x (i.e. you use K to build constant functions.)

S x y z

Generalised function application combinator: Equivalent to doing x z(y z)

1. When an element in a list was accessed, it was moved to the front of the list.
2. When an element in a list was accessed, it was moved forward one position in the list.

 proc lru {listVar maxLength item} {
    upvar 1 $listVar list
    if {![info exists list]} {set list {}}
    set pos  [lsearch $list $item]
    set list [lreplace $list $pos $pos]
    lappend list $item
    if {[llength $list] > $maxLength} {set list [lrange $list 1 end]}
    set list
 }

 proc ltuple {multilist {tuplelen 2}} {
    # init a list res (result)
    for {set i 0;set res ""} {$i<$tuplelen} {incr i} {lappend res ""}
    if {[llength $multilist]%$tuplelen!=0} {
        error "incorrect tuple length, or input mismatch"
    }
    for {set i 0;set j 0;set l [llength $multilist]} {$i<$l} {incr i;incr j;set j [expr {$j%$tuplelen}]} {
        lset res $j [concat [lindex $res $j] [lindex $multilist $i]]
    }
    return $res
 }
 # Example :
 array set table {id 2 name MAIN desc "Main process"}
 foreach {keys values} [ltuple [array get table]]
 # $keys={id name desc} and $values={2 MAIN {Main process}}

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