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 this sample shows, Algol 68G has only three sies of integer. The precission of LONG LONG INT can be specified by a pragmatic comment. The value shown here is the default.

<br>Algol 68G has 64 bit INT and 128 bit LONG LONG INT. In previous versions, INT was 32 bit and LONG INT had a precision of 35 decimal digits.<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|jq}}==

 

For example, consider the 'any' and 'all' functions, all versions of which have short-circuit semantics. The array-oriented versions of these functions are defined in terms of the more fundamental stream-oriented functions, making the redundancy plain to see:

 

 

=={{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.

broken in almost every other sense, and from the 0 bug reports clearly had never been used in the real world.

 

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Working OK.\n"</span><span style="color: #0000FF;">)</span>

<small>(In fact, if you run "p -d test.exw" on the above, <code>if true</code> .. <code>end while</code> only emits a single instruction, <code>mov i,3</code> at the start of the for loop, and no other instructions at all for those thirteen lines.)</small><br>

<small>(Also, for the above and this by inspecting the list.asm file created, you would be able to see that it doesn't bother adding 3 to i, but instead simply sets it to 6 then 9.)</small><br>

Working OK.

</pre>

 

=={{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