字符串间隔如何工作？

我做了一些玩这个答案 https://stackoverflow.com/questions/25308978/what-are-intervals-in-swift-ranges/25631930#25631930，甚至向 Apple 提出了 RADAR 问题，要求提供有关此事的更好文档（蟋蟀鸣叫）。

问题是：字符串间隔如何工作？

如果你看看我的 Playground 中的第 367 行，你会发现我在搞乱字符串间隔。

我将字符串内容提取到一个较小的游乐场中：

// String Intervals
// These are odd. Looks like it is using the ASCII values. I should experiment with Unicode, and see where we go...
let aThroughFClosed:ClosedInterval<String>          = "A"..."F"
let dThroughQClosed:ClosedInterval                  = "D"..."Q"
let mThroughSClosed:ClosedInterval                  = "M"..."S"
let tThroughWClosed:ClosedInterval                  = "T"..."W"
let whiskeyTangoFoxtrot1                            = "QED"..."WTF" /* Not sure what will happen when I start working with this... */
let aThroughHHalfOpen:HalfOpenInterval<String>      = "A"..<"H"
let dThroughRHalfOpen:HalfOpenInterval              = "D"..<"R"
let mThroughTHalfOpen:HalfOpenInterval              = "M"..<"T"
let tThroughXHalfOpen:HalfOpenInterval              = "T"..<"X"
let whiskeyTangoFoxtrot2                            = "QED"..<"WTF"
let clampedString1 = aThroughFClosed.clamp ( dThroughQClosed )  /* This represents "D"..."F" */
let clampedString2 = dThroughQClosed.clamp ( aThroughFClosed )  /* This represents "D"..."F" */
let clampedString3 = dThroughQClosed.clamp ( mThroughSClosed )  /* This represents "M"..."Q" */
let clampedString4 = dThroughQClosed.clamp ( tThroughWClosed )  /* This represents "Q"..."Q" */
let clampedString5 = aThroughFClosed.clamp ( tThroughWClosed )  /* This represents "F"..."F" */
let clampedString6 = aThroughHHalfOpen.clamp ( dThroughRHalfOpen )  /* This represents "D"..<"G" */
let clampedString7 = dThroughRHalfOpen.clamp ( aThroughHHalfOpen )  /* This represents "D"..<"H" */
let clampedString8 = dThroughRHalfOpen.clamp ( mThroughTHalfOpen )  /* This represents "M"..<"R" */
let clampedString9 = dThroughRHalfOpen.clamp ( tThroughXHalfOpen )  /* This represents "R"..<"R" */
let clampedString0 = aThroughHHalfOpen.clamp ( tThroughXHalfOpen )  /* This represents "H"..<"H" (Not exactly sure why) */

// 2.2.3: STRING INTERVALS

// String intervals are weird. Just sayin'...

// 2.2.3.1: STRING INTERVALS AS SWITCH TESTS

var testValue3:String = "B"

switch ( testValue3 )
    {
case aThroughFClosed:   /* This will catch it. */
    println ( "In A...F." )

default:
    println ( "In catchall." )
}

// Looks like the test is only on the first letter.
testValue3 = "Badz-Maru"

switch ( testValue3 )
    {
case aThroughFClosed:   /* This will catch it. */
    println ( "In A...F." )

default:
    println ( "In catchall." )
}

testValue3 = "\tBadz-Maru"   /* If we add a tab character to the start of the string, then the first test will fail. */

switch ( testValue3 )
    {
case aThroughFClosed:
    println ( "In A...F." )

default:    /* This will catch it. */
    println ( "In catchall." )
}

// Now, we'll get really strange. Let's look at our multi-character intervals...

testValue3 = "W"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* This catches it. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "T"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* This catches it. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "F"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default: /* However, in this case, it falls through to default. */
    println ( "In catchall." )
}

testValue3 = "WT"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2: /* "WT" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "WTF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default:    /* "WTF" is not caught. */
    println ( "In catchall." )
}

testValue3 = "QED"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QED" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QTF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QTF" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QSF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QSF" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QAF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default: /* QAF falls through. */
    println ( "In catchall." )
}

据我了解，ClosedInterval(lo, hi)代表所有字符串s这样

lo <= s <= hi

and HalfOpenInterval(lo, hi)代表所有字符串s这样

lo <= s < hi

where <= and <是由字典顺序弦乐的， 即逐一比较字符，直到发现差异。

例如"QED" < "T" < "WTF"因为Q < T < W, but "F" < "QED"因为F < Q。所以

HalfOpenInterval("QED" , "WTF").contains("T") == true
HalfOpenInterval("QED" , "WTF").contains("F") == false

And "QED" < "QSF"因为Q == Q and E < S, but "QAF" < "QED"因为Q == Q and A < E。所以

HalfOpenInterval("QED" , "WTF").contains("QSF") == true
HalfOpenInterval("QED" , "WTF").contains("QAF") == false

这应该可以解释你所有的测试结果。

最后，

let clampedString0 = aThroughHHalfOpen.clamp ( tThroughXHalfOpen )

is an empty间隔因为"A"..<"H" and "T"..<"X"没有共同点。 空区间可以表示为HalfOpenInterval(dummy, dummy) for any的价值dummy.