On 06/16/2010 05:47 AM, Steven Schveighoffer wrote:
On Tue, 15 Jun 2010 22:23:15 -0400, Andrei Alexandrescu
<[email protected]> wrote:
bearophile wrote:
I have counted about 200 usages of std.contracts.enforce() inside
Phobos. Can you tell me what's the purpose of enforce() in a language
that has built-in Contract Programming?
You need to read TDPL for that :o).
And what are the purposes of std.contracts.AssumeSorted()? Is it
useful for something?
AssumeSorted was an experiment. I think it has drawbacks that I don't
know how to address, so I'll retire it.
Hm... what are the drawbacks (besides it not being enforced)? I thought
it was a good solution.
Sorry I took so long (over one month!) to reply to this. I've delayed
the reply to the point when it could be integrated within the upcoming
thread about improving std.algorithm.find.
The problem with AssumeSorted is that generally predicates in D (and
also in most other languages) are not easy to compare. Let's first
recall AssumSorted's definition. It's just a wrapper:
/**
Passes the type system the information that $(D range) is already
sorted by predicate $(D pred). No checking is performed; debug builds
may insert checks randomly. To insert a check, see $(XREF algorithm,
isSorted).
*/
struct AssumeSorted(Range, alias pred = "a < b")
{
/// Alias for $(D Range).
alias Range AssumeSorted;
/// The passed-in range.
Range assumeSorted;
/// The sorting predicate.
alias pred assumeSortedBy;
}
/// Ditto
AssumeSorted!(Range, pred) assumeSorted(alias pred = "a < b", Range)
(Range r)
{
AssumeSorted!(Range, pred) result;
result.assumeSorted = r;
return result;
}
The recommended way to use the facility is:
int[] a = [ -1, 0, 1, 2, 3, 4, 5 ];
assert(find(assumeSorted(a), 3) == [ 3, 4, 5 ]);
find() uses simple means to detect that its first argument has type
AssumeSorted and takes advantage of that when searching (specifically by
doing binary search).
So far so good. The problem ensues when we want to make sure that the
sorting predicate is in sync with the search predicate. For example, if
the search predicate is "==" then it's okay to use "<" or ">" as a
sorting predicate. But searching for "a.zip == b.zip" in a range sorted
by "a.name < b.name" is not okay.
If predicates were all expressed as strings, probably some string
manipulation could be done to see whether they are compatible. But as
things stand, assertSorted has quite limited power.
Andrei
