> You gave cases for which `underestimatedCount()` is used:
>> For sequences with easily-calculated counts, this should give us a size 
>> that's just right. For sequences where they can kind of estimate the right 
>> count (for instance, if you're decoding a fixed-size buffer of UTF-8 bytes, 
>> and you know how many bytes there are but not exactly how many characters 
>> they'll decode to), it will get us at least part of the way there. For 
>> sequences whose size is completely unknown, it won't help but it won't hurt 
>> much either.
> 
> CC’ing swift-dev, I’m wondering:
> Was there a reason `underestimatedCount()` was chosen for Sequence instead of 
> `estimatedCount()`. I suppose an overestimate would be bad for iterating 
> `0..<estimatedCount()`, but I couldn’t find any existing loops over 
> `0..<underestimatedCount()`.
> 
> Does anything depend on an underestimate of Sequence count? And if not, would 
> it be better to be less restrictive when asking a Sequence for a size 
> estimate?
> Since the exact count is returned for collections, the name also isn’t very 
> precise.

Actually, the code samples I gave you *do* subtly depend on underestimatedCount 
being an underestimate, because the initial fast loop force-unwraps the element 
returned by `next`. If the count is an overestimate, that force unwrap will 
fail. You can see it in my example:

                        // Load all the fast elements
                        for _ in 0..<fastCount {
                                let elem = generator.next()!
                                
_appendElementQuicklyBecauseWeAlreadyKnowWeHaveTheCapacity(elem)
                        }

And in the actual standard library code:

          // Add elements up to the initial capacity without checking for 
regrowth.
          for _ in 0..<initialCapacity {
            builder.addWithExistingCapacity(generator.next()!)
          }

These and similar constructs could be turned into `if let`s, but that would add 
a conditional branch which would make the loop slower, particularly in 
-Ounchecked mode where safety checks are disabled. In that mode, the force 
unwrap operator simply *assumes* the value is not `nil`, which makes this code 
run as fast as possible—it pretty much can just copy or retain the element, 
assign it into the next slot in the array, and increment the array's count.

-- 
Brent Royal-Gordon
Architechies

_______________________________________________
swift-dev mailing list
swift-dev@swift.org
https://lists.swift.org/mailman/listinfo/swift-dev

Reply via email to