Are there the following (or other modal verbs) constructs in any programming language?

Question

As far as I know, I have never come across a SHOULD construct in a computer language, but again I do not know that many languages ​​are compared to hundreds.

In any case, SHOULD other modal verbs are very common in natural languages, and their meanings are very clear when writing documentation and legally binding contracts, so they are not gray terms and can theoretically be expressed in terms of programming (I Guess).

For example, ASSERT, in a sense, supports the MUST construct.

Are there any real examples of this kind of thing? Any research on this? I assume some rule-based systems, and perhaps fuzzy logic algorithms work as follows.

Answer 1

The exact meaning of the word in natural language is also not clear. When you say: “the wheel should be in a row” - what does it mean? This may mean the same as it should, but then there is no point in the design for it. Otherwise, what is the certainty that you should be satisfied? What is the action if the wheel does not fit?

There are some equivalents in the feelings you spoke of, although I don’t know the language that the word should use for them:

Testing / Approval

ASSERT often a language directive, macro, or test library function. In the sense that ASSERT matches must, some languages ​​and test environments define macros for “warning statements” that will spit out a warning message if the test fails, but the test fails or fails, which would match.

Exception Handling

In some terms, you can consider an exception that is selected as an analog - if an exception is caught, the program can handle the case when something is not as it should be. But sometimes an exception describes the rejection of how something should be the way it should be for the program to work, in which case the exception will not be caught, or the handler will make the program fail gracefully. This, however, is not always the case - sometimes code is executed to check what might or may not even be likely, and the exception is caught expecting it to be thrown.

Logic of constraints

One common meaning of must and should in various formal documents in natural language is restriction - it must indicate a restriction that you must always satisfy, and if you cannot, then your condition is incompatible, and should mean that you will always satisfy the restriction if this is possible, given the state and limitations implied by the mandatory, but if this is not possible, it is still relevant. In the informal logic of constraints, this happens when there are “external constraints” in the context, so checking that a “solution” is satisfactory with regard to “constraints” can only be possible if you know the context and given the context that you can also satisfy different subsets of " restrictions, "but not at the same time. For this reason, some specification languages ​​for constraint restrictions (whether they are called their "programming languages" depend on your definition) have the concepts of ordering constraints - the first level of constraints corresponds to the mandatory, the next level corresponds to the obligation and the constraint should be satisfied, if possible, taking into account all external external restrictions (at previous levels), even if it contradicts some restrictions at the next levels, which then will not be satisfied.

Answer 2

I think of try as "should" and catch and finally as "in case it is not."

Answer 3

This type of modality is used in RSpec -dsl to build tests in a behavior-driven style.

Answer 4

Modal verbs such as "should", "may", "may" can be confusing, so RFC 2119 provides a definition to indicate all noses in one direction:

 SHOULD This word, or the adjective "RECOMMENDED", mean that there may exist valid reasons in particular circumstances to ignore a particular item, but the full implications must be understood and carefully weighed before choosing a different course. 

From this definition, it should be clear that it should be used in the specifications, and not in the program code where you want to determine things. At least I do it. I can imagine that this can be used in AI, however.

Answer 5

Well, maybe it can be found in a language like prologue, as a milder conclusion? That is, the result should logically be x, but it may not be. You can say that the result is probably x, but not unique?

Answer 6

@Simon Perhaps Try / is finally closest. everything in Try should work, but not always. Webservice should open the socket, but if it is not, we do not care.

Answer 7

What behavior do you expect from the program if the result is not the same as SHOULD? In the case of ASSERT, this is an exception (AssertException or the like). Should a program throw an exception or just ignore the result? It seems to me that there is nothing between them. Either the result is accepted or not.

Otherwise, you should indicate what behavior you expect. :-)

Back to the statement: if the statement is not satisfied, an exception is thrown. It is up to you what you do with this exception. In java / C #, for example, you can catch it and then do whatever you want, so you determine if assert is MUST or SHOULD.

Answer 8

Well, Java2K has similar concepts. SHOULD do what he said ...

SCNR.