lselect

Klaus Saalfeld A function lselect is proposed that selects a number of items from a list and returns them as a new list. In contrast to known lindex with multiple indices lselect doesn't operate on nested lists but on flat lists. The returned list contains the items in the same order as specified with the indices argument.

Using a list argument

# Returns from the specified list one or more elements identified by given indices.
# The first element in list is given by index 0, the last element of list is given by "end".
# An optional negative offset (e.g. "end-1") can be used to specify elements relative to the end of list.
# The list to operate on is passed by value.
proc lselect {value indices} {
   set result {}
   if {0 != [llength $value]} {
      foreach index $indices {
         if {0 == [string compare -length 3 $index end]} {
            set index [expr ([llength $value] - 1) [string range $index 3 end]]
         }
         if {($index >= 0) && ($index < [llength $value])} {
            lappend result [lindex $value $index]
         }
      }
   }
   return $result
}

Some examples:

% lselect {car house tiger penguin} {end-1 1 end 0}
tiger house penguin car

% lselect {banana pineapple orange} 1
pineapple

% lselect {tcl is great} {-1 17 end-8}
<empty>

% lselect {more awesome stuff} {1 1 1}
awesome awesome awesome

Many list operations are special cases of lselect. For example:

lindex $x $n corresponds to lselect $x $n.
lrange means selecting a consecutive range of items from a list
lreplace can be used to remove elements from a list which is equivalent to selecting the remaining elements using lselect.
lreverse {a b c} is equivalent to lselect {a b c} {2 1 0}.

lselect can be combined with known lsearch to extract items from a list that match a given pattern:

% set fruits {banana ananas pineapple orange apple}
% lselect $fruits [lsearch -all $fruits a*]
ananas apple

lselect can be used to rotate values in a list:

% set x {1 2 3 4}
% set x [lselect $x {1 2 3 0}]; # Rotate to the left by 1
2 3 4 1
% set x [lselect $x {1 2 3 0}]
3 4 1 2
...
% set x {1 2 3 4}
% set x [lselect $x {3 0 1 2}]; # Rotate to the right by 1
4 1 2 3
% set x [lselect $x {3 0 1 2}]
3 4 1 2
...

lselect is moreover useful to implement stack or buffer like behavior with lists or to shuffle lists.

Using args

Larry Smith Might I suggest the slightly less verbose:

# Returns from the specified list one or more elements identified by given indices.
# The first element in list is given by index 0, the last element of list is given by "end".
# An optional negative offset (e.g. "end-1") can be used to specify elements relative to the end of list.
# The list to operate on is passed by listval.
proc lselect {listval args} {
   set result {}
   if {[llength $listval]>0} {
      foreach index $args {
         lappend result [lindex $listval $index]
      }
   }
   return $result
}

Which has (mostly) the same results. The comparisons against "end" are unneeded since lindex takes care of them itself. Using args means the indices does not have to itself be a list.

% lselect {car house tiger penguin} end-1 1 end 0
tiger house penguin car

% lselect {banana pineapple orange} 1
pineapple

% lselect {tcl is great} -1 17 end-8
{} {} {}

% lselect {more awesome stuff} 1 1 1
awesome awesome awesome

Klaus Saalfeld Hi Larry and thanks for your input. As far as I can see the results differ when an invalid index is given: Using this variant lappend concats empty values to the resulting list (which I think is not a good feature). At first I throught you're right concerning "end" handling which might be delegated to lindex. But then I thought lselect might get problems dealing with empty list items. This is because you can't tell whether lindex has not found an item or the item was found but is empty (in which case lselect should return it).

The result also differs if args is given but empty:

% lselect {a b c} {}
{a b c}

Using a lambda to select items

The function can be extended to use apply to decide which items to select:

proc lselect {value indices args} {
   set result {}
   set length [llength $value]
   if {$length > 0} {
      if {$indices ne "-apply"} {
         foreach index $indices {
            if {0 == [string compare -length 3 $index end]} {
               set index [expr {($length - 1) [string range $index 3 end]}]
            }
            if {($index >= 0) && ($index < $length)} {
               lappend result [lindex $value $index]
            }
         }
      } else {
         foreach item $value {
            lappend result [apply {*}$args $item]
         }
      }
   }
   return $result
}

This is useful to select items based on their value or to transform items:

;# Square all values in list
% lselect {3 5 1 4} -apply {{x} {return [expr {$x*$x}]}}
9 25 1 16

;# Apply a lower limit on values in list
% lselect {1 -3 7 2} -apply {{x} {return [expr {max(0, $x)}]}}
1 0 7 2

Moreover items can be removed from a list depending on their value:

;# Get all positive non-zero values from a list
% lselect {9 1 -3 5 -7} -apply {{x} {if {$x > 0} {return $x} else {return -code continue}}}
9 1 5

;# Get all values until a zero or negative value is found
% lselect {3 2 1 0 -1 -2 -3} -apply {{x} {if {$x > 0} {return $x} else {return -code break}}}
3 2 1

lselect

Using a list argument

Using args

Using a lambda to select items

See also