[Tcl-bugs] [Bug #119378] "string range" enhancement request

[<no...@so...>]

Bug #119378, was updated on 2000-Oct-25 22:11
Here is a current snapshot of the bug.

Project: Tcl
Category: Commands M-Z
Status: Open
Resolution: None
Bug Group: Feature Request
Priority: 1
Submitted by: nobody
Assigned to : nobody
Summary: "string range" enhancement request

Details: OriginalBugID: 6023 RFE
Version: 8.3.1
SubmitDate: '2000-07-19'
LastModified: '2000-10-25'
Severity: LOW
Status: UnAssn
Submitter: techsupp
OS: Macintosh
OSVersion: linuxppc  linux-kernel 2.2.14pre9 (will be MacOS-X :-)
Machine: Macintosh Blue G3
FixedDate: '2000-10-25'
ClosedDate: '2000-10-25'


Name:
Maurice Diamantini

Extensions:
nothing

CustomShell:
nothing

DesiredBehavior:
"string range" should accept a list as indices arguments
so the syntaxe could becomme:

  string range string first last

instead of simply:

  string range string pairList

------------------------------------------------------------
Exemple:

  set txt "aaa123bbb679ccc"
  set pat {(\d+)\D*(\d+)}
  regexp  -indices $pat $txt  all  var1_indexes var2_indexes
  # ... drop things made with indices ...
  # then get the chunks of txt :
  set var1 [string range $txt  [lindex $var1_indexes 0]  [lindex
$var1_indexes 1]]

  set var2 [string range $txt  [lindex $var2_indexes 0]  [lindex
$var2_indexes 1]]

As list data type a powerfull feature of the Tcl language, 
I'd prefer to be able to write :

  set var1 [string range $txt $var1_indexes]
  set var2 [string range $txt $var2_indexes]

Or even (if needed)
  set varChunk [string range $txt "$var1_indexes $var2_indexes" ]

------------------------------------------------------------  
Obiously one can do a proc for it :

  ## String:range -- return sub-string based on pair list of indices
  # 
  # Do the same as "string range" tcl command, but take a list of 
  # two indices instead of two indices as parameters
  # (then extended to take an arbitrary pair list)
  # 
  # example:
  #     set txt "aaa123bbb679ccc"
  #     set pat {(\d+)\D*(\d+)}
  #     regexp  -indices $pat $txt  all  var1_indexes var2_indexes
  #     set var1 [String:range $txt $var1_indexes]
  #     set var2 [String:range $txt $var2_indexes]
  #     set varChunk [String:range $txt "$var1_indexes $var2_indexes" ]
  # 
  proc String:range {str indices} {
      set res ""
      foreach {first last} $indices {
          append res  [string range $str $first $last]
      }
      set res
  }





Follow-Ups:

Date: 2000-Dec-06 02:36
By: dkf

Comment:
OK, I think I perhaps ought to explain myself.

Firstly, it is trivially easy to work around this using [foreach], though
this is a messy solution, admittedly.

Secondly, the optimal current work-around may well be this:
   eval [linsert $list_of_two_indices 0   string range $string]
(It is optimal since it guarantees that there is no real double evaluation
of any values, even though it lacks a lot on the "optimality of
representation" front too.)

Thirdly, a full solution ought to address the fact that there are many
places in Tcl where this sort of conversion of lists to multiple arguments
would be useful, and that a more general solution (a la the {expand}$list
discussion of a few months back) would be a far more efficient use of
people's time than a horde of special fixes scattered throughout Tcl, Tk
and all the various extensions.  If nothing else, the maintenance overhead
is much lower.  (Not that I'm advocating a particular syntactic construct
here - just the general concept.)  Perhaps I ought to go back over that
discussion and see if a suitable TIP can be culled from it...?  Only
problem with doing this is that it results in a shed-load of work falling
on me from a great height...  :^)
-------------------------------------------------------

Date: 2000-Dec-05 23:27
By: welch

Comment:
The "eval" command provides a general way to split arguments.

eval [list string range $string] $list_of_two_indices
or
eval {string range $string} $list_of_two_indices

I'm inclined to agree with the original request, however, because the the

use of eval may add more overhead than you want with large strings.
It'd be worth measuring the eval approach to see if it's worth a special
case.
-------------------------------------------------------

Date: 2000-Nov-15 06:49
By: dkf

Comment:
I'm reluctant to add this sort of thing just here because it is patching a
single spot instead of addressing the wider problem of splitting arguments.
 A general solution so that expansion of lists into several command
arguments would be a much more effective use of time...
-------------------------------------------------------

For detailed info, follow this link:
http://sourceforge.net/bugs/?func=detailbug&bug_id=119378&group_id=10894