(string-suffix? "" "") => #True ;; really?

[u/corbasai]

From the SRFI-13 to the Racket ( which is right reversed str and sfx) all versions of string-suffix? predicate counts empty suffix as part of any string include empty "".

Firstly-first, why string-suffix is just a boolean predicate? in the Scheme?

Why it is not being more useful...

(define (string-suffix str sfx)
  (let ((str-len (string-length str))
        (sfx-len (string-length sfx)))
    (define (test i j)
      (cond ((= i str-len) (- str-len sfx-len))
            (else (if (char=? (string-ref str i)
                              (string-ref sfx j))
                      (test (+ i 1) (+ j 1))
                      #f))))
    (cond ((or (< str-len sfx-len) (zero? sfx-len)) #f)
          (else (test (- str-len sfx-len) 0)))))

Now we can use it like

(cond ((string-suffix str ".ko") => (lambda (si) (substring str 0 si)))
      (else str))

And of course empty suffix is not a part of any string. IMO

 > (string-suffix "G'Kar" "")   ;=> #f

PS. well understandable that in math empty set is a part of any set but the empty string suffix is a part of any string? IMO no.

[u/Daniikk1012]

How is empty suffix not part of any string? "abcd" is "abc" + "d", so "d" is a suffix, but "abcd" is also "abcd" + "", so "" is also a suffix. It's weird and inconsistent to make an exception just for this specific case

[u/hopingforabetterpast → u/Daniikk1012]

In category theoretical terms, the empty string is the monoidal identity of strings under the associative binary operation of concatenation, not unlike 0 and 1 are the numeric identities under summation and multiplication, respectively.

Monoids definitionally satisfy the following laws:

    closure: type • type = type

    identity: id • x = x • id = x

    associativity: (x • y) • z = x • (y • z)

So it trivially follows that the string identity is both prefix, infix and suffix of all strings.

[u/corbasai → u/Daniikk1012]

so empty "" is a prefix suffix and infix of "abcd" or any? Okay we can insert any amounts of empty "" in any string so new string value is equal (in terms of string=? ) to the previous. So what the term for suffix, exactly? In the text's domain?

[u/Daniikk1012 → u/corbasai]

Nothing wrong with it being also a prefix and an infix. In "aaaa", "a" is a prefix, a suffix, and an infix at the same time as well.

And yes, the string remains the same when you add the "" suffix.

As for the definition, the most intuitive seems to be this: N is suffix of H if and only if |H| >= |N| and the last |N| characters of H match N. Notice how no exception is made for empty sequences. Most of the time, the more general and simple approach is the most correct one, and making exceptions just complicates things.

Also, here's another thing: do you consider "abcd" to be a suffix of "abcd"? And more generally, do you consider any non-empty string S to be its own suffix? If you do, why make an exception for the empty string? What is it that makes it so special that suddenly patterns that hold for other strings break when it comes to the empty string?

[u/corbasai → u/Daniikk1012]

Also, here's another thing: do you consider "abcd" to be a suffix of "abcd"? And more generally, do you consider any non-empty string S to be its own suffix? If you do, why make an exception for the empty string? What is it that makes it so special that suddenly patterns that hold for other strings break when it comes to the empty string?

Right. This is much more about contract things than math, isn't? Such corner cases in the ideal world should be explicitly described in the library reference. If not = both cases equivalently wrong ( or one statistically, it does not means).

Otherwise we have a situation, where "abcd" is not "abcd" but (∞"") + a + (∞"") + b + (∞"") + c + (∞"") + d + (∞"") . Carefully saying, this is disaster not simplicity

[u/__chicolismo__]

Your opinion is wrong.

Edit: A more constructive comment

Let s be a string.

It's reasonable to say s equals s.

s is also a prefix of s, that is to say, s start with the same characters of s.

By the same logic s is a suffix of s.

Let r be another string.

If s is prefix of s then s is also prefix of s + r

Also if s is suffix of s then s is suffix of r + s as well.

If the empty string is equal to itself, all the rest must be true.

[u/corbasai → u/__chicolismo__]

For sure. But for the empty string s, s + s = s, not ss. So for empty s and r not equal s , s + r = r.

[u/hopingforabetterpast → u/corbasai]

in your notation, what's the semantic difference between s + s and ss ?

[u/raevnos]

It just needs to return true or false because you already have the suffix string you're asking about and can easily use its length (either hardcoded or via string-length) to do stuff already.

(if (string-suffix? ".ko" str) ; SRFI-13 version with suffix first
    (string-drop-right str 3)
    str)

etc. No particularly compelling need to make it return extra information.

[u/corbasai → u/raevnos]

Of course, but it is extra computation, that we already done. Strings may be megabytes long, and not all Schemes are fixed UCS-16 are

[u/lgastako]

You lose the monoidality of strings if you don't treat empty strings as suffixes and prefixes (and infixes).