Useless instructions: Difference between revisions

{{draft task}}

 

;Task

<code>CMP #0</code> is nearly completely useless, as most 6502 instructions do this implicitly. It can be handy when you need to check equality to zero after a different register was altered, and in that scenario using <code>PHP/PLP</code> to save and restore the condition codes would be impractical, but these situations are few and far between.

 

;do stuff here

dex

;cpx #0 ;this isn't needed since the zero flag will be set if x=0

 

=={{header|68000 Assembly}}==

=={{header|Action!}}==

The Action! language has four fundamental data types, BYTE, CHAR, INT and CARD. The first two can be used interchangably and are 8-bit unsigned integers. This is presumably for documentation purposes, however the language also has a macro facility that would allow the programmer to <code>DEFINE CHAR="BYTE"</code> or <code>DEFINE BYTE="CHAR"</code> if only one was available.

 

=={{header|ALGOL 68}}==

As well as being able to write <code>IF TRUE THEN SKIP ELSE some code that will never be executed FI</code> and <code>WHILE FALSE DO some code that will never be executed OD</code>, as in other languages shown here, Algol 68 has a feature that was presumably intended to aid portability (though whether it does in practice is another matter...):<br>

Algol 68 has a notionally infinite number of integer, real and comples types. THe standard types INT, REAL and COMPL, can have an arbitrary number of LONG or SHORT prefixes to indicate larger or smaller types. Whether these are actually larger or smaller depends on the implementation - no warning is issued (at least, not in Algol 68G) to indicate that e.g. LONG LONG LONG REAL is not longer than LONG LONG REAL. In addition, there are "environment enquiries" that will reveal how big the types are, so e.g. max int is the largest INT value, long max int is the largest LONG INT value, etc. An arbitrary number of long and short prefixes can be applied.<br>

print( ( long long max int, newline ) );

print( ( long max int, newline ) );

short short short short short short short short short short

short short short short short short short short short short

{{out}}

<pre>

</pre>

=={{header|AWK}}==

# syntax: GAWK -f USELESS_INSTRUCTIONS.AWK

BEGIN {

delete array

}

 

=={{header|C}}==

Another keyword which is teetering on redundancy is 'register' whose purpose is to suggest to the compiler that it should store a variable in a CPU register rather than memory. However, modern optimizing compilers don't need such a suggestion and will use CPU registers anyway if they deem it appropriate. But it may still be relevant in embedded system programming so it can't be said to be completely redundant at the present time.

 

#include <stdbool.h>

 

uselessFunc(0);

printf("Working OK.\n");

 

{{out}}

Working OK.

</pre>

 

=={{header|Go}}==

 

However, nothing's perfect and the analogous redundant constructions which are allowed in Wren are not picked up by the Go compiler either as the following program shows.

 

import (

set[0] = NotCompletelyUseless{} // duplicate key so not added to set

fmt.Println(set)

 

{{out}}

map[0:{}]

</pre>

 

=={{header|Julia}}==

arrays of `Bool` type. This makes the `count()` function redundant except to better express

intent to count rather than add.

 

@show count(array) # count(array) = 4

@show sum(array) # sum(array) = 4

 

=={{header|Nim}}==

Also, when defining a type with variants, when a branch doesn’t contain any field, we can use the keyword <code>discard</code> (as in a case statement) or the value <code>nil</code>.

 

case i: 0..2

of 0: value: int

of 1: discard

 

But, as <code>discard</code> is used as empty statement and <code>nil</code> is used as null value for references and pointers, we cannot say that they are useless even if they are synonyms in one context.

The five core builtin types form a natural hierarchy, so you can store an integer in a variable declared as

an integer or a number (aka atom), the latter in an object, and a string in a string or a sequence, and the

Phix supports at least 45 different ways of expressing the same simple integer value, from binary to base 36,

and that is before even considering string versions of it. For instance there is no difference whatsoever

One genuinely redundant feature which has since been redacted was "{a, b, c} @= x", where the "@=" was meant to

stand for "all become equal to". Technically it just about worked when x was a literal integer, but was badly

 

=={{header|Raku}}==

 

Some examples: Say you have a variable $x that holds an integer, and you want to add 1 to it.

 

$x = $x + 1; # classic

++$x; # pre-increment

$x++; # post-increment

 

''Raku is by no means unique in that regard.'' Each one of those nominally accomplishes the same thing, though they go about it in slightly different ways, and are intended for slightly different purposes. Redundant on the face of it, but different reasons for each.

There may be different operations that essentially perform the same function that have been retained for historical compatibility and / or ease for crossover programmers. the <code>for next</code> construct really only exists in Raku for programmer convenience. Internally it is converted to a map operation. Programmers can use map directly, but if they come from a language that doesn't provide map, and aren't used to it, <code>for next</code> is a easy stepping stone.

 

 

Syntactic sugar (typically) replaces some longer expression with a shorter, more easily typed one. Raku abounds with them.

 

my @a1 = Q:w[one two three]; # list of strings using the Q sublanguage

my @a2 = <one two three>; # syntactic sugar for the same operation

say (1,2,3,4,5,6,7).reduce(&infix:<*>); # multiply all of the items in a list together

say [*] (1,2,3,4,5,6,7); # same operation, sweeter syntax

 

=={{header|Wren}}==

 

For good measure I've also included something which looks useless but isn't in fact.

if (true) {

// do something

 

uselessFunc.call(0)

 

{{out}}

Compare the following code snippets, which are functionally identical but the latter is half the size and more than double the speed:

 

SET 6,A

RES 5,A

OR %11000000

AND %11001111