Jak działają interwały ciągów znaków?

Question

Zrobiłem trochę zabawy w this answer, a nawet podniosłem problem RADAR z Apple, prosząc o lepszą dokumentację w tej sprawie (świerszcze Świerszcze).

Pytanie brzmi następująco: Jak działają interwały ciągu?

Jeśli spojrzysz na linię 367 na moim placu zabaw, zobaczysz, że mam problemy z interwałami ciągów.

I wyjął rzeczy String na mniejsze Plac zabaw:

// 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.") 
} 

Answer 1

Jak rozumiem, ClosedInterval(lo, hi) reprezentuje wszystkie ciągi s takie, że

lo <= s <= hi 

i HalfOpenInterval(lo, hi) reprezentuje wszystkie ciągi s takie, że

lo <= s < hi 

, gdzie <= i < są określone przez leksykograficznej zamawiania strun, to być porównanie znaki, jeden po drugim, aż różnica występuje.

Na przykład "QED" < "T" < "WTF" ponieważ Q < T < W, ale "F" < "QED" ponieważ F < Q. Dlatego

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

I "QED" < "QSF" ponieważ Q == Q i E < S, ale "QAF" < "QED" ponieważ Q == Q i A < E. Dlatego

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

To powinno wyjaśnić wszystkie twoje wyniki testu.

Wreszcie

let clampedString0 = aThroughHHalfOpen.clamp (tThroughXHalfOpen) 

przerwa pusty ponieważ "A"..<"H" i "T"..<"X" nie mają punktów wspólnych. Pusta przerwa może być reprezentowana przez HalfOpenInterval(dummy, dummy) dla dowolną wartośćwartość dummy.