foreach a $list_a {
    foreach b $list_b {
        for {set i 0} {$i < [string length $b]} {incr i} {
        do_sth_with_a_and_b
        }
    }

1: use the elements of list_b as the indexes of an array and for each
item in list_a see if the index exists, man n info and look at exists

2: you could use the lindex command to search list_b for item_a

and both lookups can be done in 1 loop and an if, ok you need to
loop over list_b to load it into the array but that is setup.

I have no idea why the inner for loop is there thou so I might
have missed something.

good luck,

http://tcllib.sourceforge.net/doc/struct_set.html

list_a = peter
list_b = foobarpeter, fooketerbar, foobarfoo

So "peter" is compared against each string in list_b. In the first iteration
peter and foobarpeter face each other. Here is where the for loop and
do_sth_with_a_and_b come into play. The word peter gets shifted through
foobarpeter to see if there is a match (or a fuzzy match, the fuzzy proc
returns a value between 0 and 1, and with >0.8 i give it a match). So
basically like this:

peter
fooba

peter
oobar

peter
obarp

and so on. (it actually checks peter against 6 characters, but that doesn't
matter here). do_sth_with_a_and_b just calls the fuzzy proc that returns a
value, if >0.8 the string from list_b gets added to a list and i break from
the current loop.

Maybe that's a stupid way to do this, but it's the only way i came up with.
About the error: I could never reproduce it on my computer, seems both the
debian package and activestate tcl already come with a reasonable
maxNestingDepth value. The computer where it happens is running the default
redhat tcl package i think, but i got no access to it for recompiling or
anything. I'd also prefer to fix the code instead of running around
recompiling :)

And being very jealous if you are truly calculating convolutions on
strings, something I have only had wet dreams of :)

        set a_list [split [string tolower $a] {}]
        set tmpresults []

        foreach b $list_B {

            # no need for fuzzy compare, there is a match
            if {[regexp -nocase $a $b]} {
                lappend tmpresults $b
                continue}\

            set b_list [split [string tolower $b] {}]

            #shift a through b, and compare a against a substring of b of
the length a+1
            #(because fuzzy looks one character ahead). do a simple fuzzy
compare.
            for {set i 0} {$i < [expr {[llength $b_list] - [llength
$a_list]}]} {incr i} {
                if {[fuzzzy $a_list [lrange $b_list $i [expr {[llength
$a_list] + $i}]] 1 -1 0] > 0.75} {
                    lappend tmpresults $b
                    break}}
        }
        #if there are multiple strings in $list_A then all strings from
$list_B that didn't show a match in the
        #previous run don't need to be checked again.
        set list_B $tmpresults
    }

set all_matches $list_B

proc fuzzzy {a b next previous result} {
#next = 1, previous = -1

    foreach i $a j $b {
        if {[string equal $i $j]} {
            set result [expr {$result + 1.00}]}\
        elseif {[string equal $i [lindex $b $previous]]} {
            set result [expr {$result + 0.585}]}\
        elseif {[string equal $i [lindex $b $next]]} {
            set result [expr {$result + 0.585}]}
        incr previous; incr next
        }

    return [expr {$result/[llength $a]}]

Could you be so kind and provide a sample set of list_A and list_B that
would demonstrate usage for this? I am wondering whether or not that funny
regexp is really supposed to match *anything* from list_B that includes
something from list_A.

The Magick doesn't happen when only swap has happened (strings are the
same length)?

And, finally, does the logic fail in the end, when "if there are multiple
strings in $list_A then all strings from $list_B that didn't show a match
in the previous run don't need to be checked again.", shouldn't you scrap
those that _did_ match and keep those that didn't, or should list_A be
some sort of iterative list that focuses bit-by-bit?

But very fancy snippet, if I only were awake enough to understand what it
does... Well, maybe in the morning, and with sample lists :P

You are right, i'm not really comparing strings here, what i'm
actually doing is finding strings in strings. An example:

list_A = peter, newspaper
list_B = "some peter guy who works at thenewspaper", "some peter who
doesnt", "another petar who works at some nuwspapreveryday"

So first i filter all strings out that got peter in them and then i
take the
matches and check if any of them also matches newspaper. The regexp
grabs
all the matches withouth spelling/typing errors, the rest is for the
fuzzy
proc.