Inverted syntax: Difference between revisions

In traditional syntax conditional expressions are usually shown before the action within a statement or code block:

In inverted syntax, the action is listed before the conditional expression in the statement or code block:

'''Inverted syntax with assignment'''

In traditional syntax, assignments are usually expressed with the variable appearing before the expression:

In inverted syntax, the expression appears before the variable:

'''Task'''

The below example will result in an assemble time error. The intended action is that the X variable is decremented, and execution returns to the top of the loop. However, the branch is simply too far away.

; more than 127 bytes of code

dex

bne loop_MySubroutine ;assembler will display an error message that the branch is too far away.

The easiest way to overcome this limitation is to invert the branch condition and place a <code>JMP</code> back to the loop under it.

An unconditional <code>JMP</code> moves the program counter to the specified location, no matter where that is.

; more than 127 bytes of code

JMP loop_mySubroutine

continue:

Now, what happens is that the opposite condition is checked. If X = 0, execution branches 3 bytes forward to "continue." Otherwise, the statement underneath the branch is executed, which is a jump back to the top.

===16-Bit Data===

Being a little-endian CPU, the "low byte" (rightmost 2 digits) of a 16-bit (4-digit) hexadecimal number is stored <i>before</i> the "high byte" (leftmost 2 digits). This is difficult for a human to read but easier for the CPU. The assembler allows the programmer to use a <code>dw</code> or <code>word</code> directive to define 16-bit data values in a manner easier for a person to read. The assembler swaps the order of the bytes automatically when assembling the source code.

A hexdump of these bytes would display them the same, i.e.: <pre>EF BE EF BE</pre>

The only place where syntax is kind of inverted is <code>exit when</code> to exit loops:

loop

exit when Foo = 10;

Foo := Foo + 1;

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# Assignment in Algol 68 is via ":=" which is automaically provided for all modes (types) #

# However we could define e.g. "=:" as an inverted assignment operator but we would need to #

( VOID: print( ( "NO", newline ) ) ) WHEN a = b; # the anonymous PROC VOID is not called #

{{out}}

<pre>

Typically, instructions with a destination register and a source register will have the leftmost register be the destination and the registers to the right be the source.

However there is one exception: the <code>STR</code> command. Its source is on the left and its destination is on the right. This inverted syntax is not optional.

This was most likely done for symmetry with the "push/pop" commands:

=={{header|Arturo}}==

In this case, we can define a reversed if-statement function (taking the block first, then the condition) and then "alias" a new symbol to it, as an infix operator (so that the block actually comes first, in terms of syntax:

if condition -> do block

]

variable: true

[print "Variable is true!"] ?? variable

{{out}}

=={{header|Bracmat}}==

The match operator <code>:</code> can play the role of an inverted assignment operator <code>=</code>. The following two definitions of a function <code>double</code> are equivalent.

double=.!arg+!arg;

(=.!arg+!arg):(=?double); { inverted assignment syntax, same result as above. }

Bracmat evaluates all left hand sides of all binary operators. How right hand sides are treated depends on the operator. The <code>=</code> operator does not evaluate its right hand side at all. The right hand side of the <code>:</code> operator is evaluated by a dedicated match evaluator, which for example sees the expression <code>?double</code> as a variable to be bound to some part of the left hand side of the <code>:</code> operator.

The following two assignments are not equivalent:

3+7:?foo { assigns 10 to foo }

=={{header|C}}==

The original would be "if (foo()) a = 4;" Here is the inverted if logic using "otherwise ... given () ;"

#include <stdio.h>

#include <stdlib.h>

exit(0);

}

Which actually makes the main program look like:

main()

{

exit(0);

}

To make lint happy you need a /*FALLTHROUGH*/ before the case 0 (in the macro).

=={{header|C++}}==

Though rarely, if ever, used in practice, user-defined class types can have inverted syntax with assignment.

int data;

public:

std::cout << a.getData() << ' ' << b.getData() << '\n';

It doesn't work if the left operand is not of the type <tt>invertedAssign</tt>.

The "thread last" macro permits inversion of syntax in virtually all contexts. Any form for which the construction of a new list from consecutive elements doesn't change the semantics may be turned "inside-out"; this is to the exclusion of those containing function definitions and little else.

(if (= 1 1)

(print "Math works."))

(->> (print a " is " b)

(let [a 'homoiconicity

Expanding the macro reveals the nature of the aforementioned limitation.

(macroexpand-1 '(->> 5 (fn [x] (* x x))))

The "thread first" macro (colloquially, the Thrush) provides a similar facility, wherein each expression becomes the first argument to the next.

=={{header|CoffeeScript}}==

CoffeeScript allows loop constructs and conditionals to be written in a suffix manner. Loop constructs evaluate to an array containing the result of each iteration; conditionals evaluates either the true-case expression or the false-case one.

alert "hello again" unless false # the same as the above; unless is a negated if.

idx = 0

=={{header|Common Lisp}}==

(defun unrev-syntax (form)

(cond

(defmacro rprogn (&body forms)

Interactive test run:

(operator argument*) where argument* is the result of applying the unreversal to the argument:

(defun unrev-syntax (form)

(cond

(defmacro rprogn (&body forms)

<pre>[1]> (rprogn ((1 + 2) * (3 + 4)))

D enables a function to be called as if it were a method of its first argument. This feature often leads to natural syntax and readable, left-to-right expressions:

import std.algorithm;

assert(r.equal([8, 16, 10, 14]));

=={{header|EchoLisp}}==

;; use reader macros to transform (a OP b) into (OP b a)

compiled :: (#when raining 'umbrella-need)

=={{header|Factor}}==

Since code is data in Factor, we can simply reverse it, transforming postfix into "prefix."

[ + 1 1 ] reverse call ! 2

{ 1 2 3 4 5 } [ sq ] map ! { 1 4 9 16 25 }

In fact, using a Lisp-style macro, we can perform this transformation at parse time:

Of course, this isn't true prefix because <code>+</code> retains its arity of <tt>2</tt>:

We can define a more accurate prefix macro for addition and subtraction in terms of <code>reduce</code>:

Additionally, using parsing words, we can add any syntax we like. The <code>infix</code> vocabulary is an example of this:

[infix

5*(1+1) ! 10

=={{header|Fortran}}==

Leaving aside those who think that Fortran is inherently backward, assignment in Fortran is firmly right-to-left in the form <code>''variable'' = ''expression''</code> where the ''expression'' is computed in accordance with the precedence rules and the resulting value is assigned to the ''variable''.

Here, a logical variable MAYBE is to receive the value of whether or not the disc file named in FILENAME(1:L) exists, and integer variable RESULT contains an error code, zero if all went well - the file name may not be correctly formed, for example. Thus, FILE is receiving a value right-to-left on entry to the statement, while MAYBE and RESULT receive values left-to-right on exit from the statement. Despite appearances, <code>ERR = 666</code> is not an assignment statement; 666 is not an integer, it is a statement label to which execution will jump should an error arise. Similar arrangements apply for the file OPEN and CLOSE statements.

FreeBASIC has nothing like this built into the language.

The nearest we can get is to define macros which reverse the order of the arguments:

#Define ThenIf(a, b) If b Then a

InvertAssign(a, b)

Print "b is"; b

{{out}}

Simulating inverted syntax with assignment is not possible.

import "fmt"

needUmbrella = itrue.iif(raining)

fmt.Printf("Is it raining? %t. Do I need an umbrella? %t\n", raining, needUmbrella)

{{out}}

However, for the common case where you want to perform a certain action only when some condition holds, you can define a simple binary operator:

action `when` condition = if condition then action else return ()

Example usage:

Haskell has a feature that can be considered "inverted" syntax (although it is not one of the types listed in the description of the task): The definition of local variables to be used in a function can be placed in a <code>where</code> clause that comes ''after'' the function body:

This is in contrast to <code>let</code> expressions, where the definition of local variables comes before the scope that uses them:

let y = a * b in

----

'''bool x y p''' evaluates to '''x''' when '''p''' is '''False''', and evaluates to '''y''' when '''p''' is '''True'''.

main :: IO ()

<*> ["No need"]

<*> ["UMBRELLA !"]

{{Out}}

<pre>No need

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon can use [[Icon%2BUnicon/Intro#Conjunction.2C_yielding_a_different_result|expression conjunctions that select different sub-expression results]] to create this effect.

raining := TRUE := 1 # there is no true/false null/non-null will do

if \raining then needumbrella := TRUE # normal

needumbrella := 1(TRUE, \raining) # inverted (choose sub-expression 1)

=={{header|J}}==

=={{header|jq}}==

jq's syntax for associating a value with a variable is "inverted": the expression for associating a value, v, with a variable, $x, is:

Note, however, that there is limited support for the conventional "target = value" syntax in the context of JSON objects and arrays, but the semantics is purely functional. <br>

For example, if o is {"a": 1}, then the expression:

=={{header|Julia}}==

Can be easily implemented as a macro:

cond isa Expr && cond.head == :if || throw(ArgumentError("$cond is not an if expression"))

cond.args[2] = expr

end

=={{header|Kotlin}}==

Kotlin can get close to an inverted 'if' syntax by defining an infix function - 'iif' say. However, there doesn't appear to be a way to mimic inverted assignment.

infix fun Boolean.iif(cond: Boolean) = if (cond) this else !this

val needUmbrella = true iif (raining)

println("Do I need an umbrella? ${if(needUmbrella) "Yes" else "No"}")

{{out}}

Latitude, by default, does not support inverted conditionals, as its two primary means of conditional branching both involve the condition first.

local 'needUmbrella = False.

{ raining. } ifTrue {

needUmbrella = True.

However, such constructs can easily be added to the language.

localize.

if ($1) then {

;; Example usage

{ needUmbrella = True. } when (raining).

Likewise, inverted assignment syntax is not supported natively, but it can be approximated in-language, using a definition similar to that of the built-in <code>local=</code>.

local 'a = 6.

let 6 = 'b.

=={{header|Lua}}==

In general, Lua does not support any ''truly'' inverted syntax, though there are some metamethod techniques and taking advantage of syntactic sugar that perhaps at least give the ''illusion'' that syntax has been inverted. Here, calling a library method passing a table, versus the table itself calling as if its own method, equivalently:

table.sort(a) -- library method passing a as param

print(table.concat(a)) -- and again --> "12345"

setmetatable(b, {__index=table}) -- ..but now "meta-decorated"

b:sort() -- syntax sugar passes b as "self"

=={{header|M2000 Interpreter}}==

The third one is more complicated. We make a callback function which act as code of a module, with same scope, and use a module to check condition before we call the callback function

expr=lambda ->{

Print "ok"

ExecCond Lazy$(&aa()), A=1

Print x=2

=={{header|m4}}==

to invert the arguments to the builtin macro, <code>ifelse</code>.

dnl

ifelse(eval(23 > 5), 1, 23 is greater than 5)

ifelse(eval(23 > 5), 0, math is broken)

thenif(23 is greater than 5, eval(23 > 5), 1)

This example outputs these four lines.

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Traditional form:

->4

Print["This was expected"]

]

Inversion of syntax:

These two clauses are exactly the same:

progress(Past, Future, At, Total) :-

At = Past + 1,

progress(Past, Future, At, Total) :-

Past + Future = Total,

Order doesn't matter even when a data dependency tells you (and Mercury's compiler) what the order of evaluation must be:

example(N) = S :-

from_int(N) = S0,

example(N) = S :-

pad_left(S0, '0', 3, S),

Data dependencies are most obvious when state is threaded through a clause:

io.write_string("Hello, ", IO0, IO1),

io.write_string("world!\n", IO1, IO).

main(!IO) :-

io.write_string("Hello, ", !IO),

The io.write_string/2's in the first example could be written in either order and the result would be the same, as the "world!\n" can't be written until the "Hello, " provides the IO1.

The order is still enforced by a data dependency, so

io.write_string(X, !IO), io.nl(!IO),

some_long_uninteresting_thing(X).

main(!IO) :-

io.nl(!IO), io.write_string(X, !IO),

=={{header|Metafont}}==

Although there is an assignment operator, you can also define values of variables by equations, such as:

Therefore it can be done both ways.

Inverted syntax in Nim can be achieved through the use of templates as operators:

# if statements

#--

# Inverted syntax

=={{header|Oforth}}==

=={{header|OxygenBasic}}==

Macros may have localised scope, so they can be safely deployed as HumptyDumpty words.

macro cond(a,c) {c then a}

cond store(5,a), if c>4

=={{header|PARI/GP}}==

{{works with|PARI/GP|version 2.4.2 and above}}

GP does not include a syntax-inverted if, but that can be defined using closures.

if(raining, print("Umbrella needed"))

PARI can also be used to implement it more directly in GP.

Perl already has that:

print 'Wow! Lucky Guess!' if $guess == 6; # Inverted syntax (note missing braces and parens)

unless ($guess == 6) { print "Sorry, your guess was wrong!"; } # Traditional syntax

Inverted syntax can also be used with the ternary operator.

However this may produce different results to the traditional syntax form because when inverted syntax is used, we are effectively making an assignment to a ternary expression. so in the following example code, instead of the assignment being made to variable a (as it is in the traditional syntax form), the inverted syntax form will cause assignment to be made to either b or c, depending on value of the ok variable:

# may produce differing results from the traditional syntax form

$a = $ok ? $b : $c; # Traditional syntax

We can also emulate inverted syntax for scalar assignment by creating a function as follows:

$a = $b; # Traditional syntax

Inverted list assignment is not possible because it prevents arrays from flattening.

=={{header|Phix}}==

original... the got still you've as long as ,itself compile/run to used be can This

<span style="color: #008080;">if</span> <span style="color: #008080;">end</span>

<span style="color: #0000FF;">(&</span><span style="color: #008000;">"test.exw"</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span><span style="color: #000000;">cl</span><span style="color: #0000FF;">)</span><span style="color: #7060A8;">system</span>

<span style="color: #008080;">js without</span>

<span style="color: #000000;">demo</span><span style="color: #0000FF;">\</span><span style="color: #000000;">rosetta</span><span style="color: #0000FF;">\</span><span style="color: #000000;">inverted_syntax</span><span style="color: #0000FF;">.</span><span style="color: #000000;">exw</span> <span style="color: #000080;font-style:italic;">--</span>

I should note that "if length(cl)>2 then" gets away by the skin of its teeth and would break were it written "if length(cl) > 2 then".<br>

... and here is the original, which can be used to first create and then re-run to compile/run the above, in fact destroying/restoring/recreating it in the latter process.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\inverted_syntax.exw</span>

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>

<span style="color: #7060A8;">system</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]&</span><span style="color: #008000;">"test.exw"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{header|PicoLisp}}==

We define a read macro for reverted syntax

Test:

<pre>(de needUmbrella (Raining)

=={{header|PowerShell}}==

The PowerShell syntax for an 'if' statement is very normal:

if ((Get-Date 5/27/2016).DayOfWeek -eq "Friday") {"Thank God it's Friday!"}

{{Out}}

<pre>

</pre>

The order of the condition and expression can be easily reversed (with a slight change in syntax):

function Action ([scriptblock]$Expression, [Alias("if")][bool]$Test)

{

say {"Thank God it's Friday!"} -if (Get-Date 5/27/2016).DayOfWeek -eq "Friday"

{{Out}}

<pre>

The facts themselves are usually expressed using "functors" involving parentheses, with the constant in front of the parentheses naming some property which applies to one or more items inside. As a result, they sometimes kind of look like backwards "is" statements.

% Also, you become a vampire if someone who is a vampire bites you.

vampire(dracula).

% Oh no! Dracula just bit Bob...

{{out}}

=={{header|Python}}==

=={{header|Qi}}==

(define set-needumbrella

Raining -> (set needumbrella true) where (= true Raining)

(define set-needumbrella

A -> (set needumbrella A))

=={{header|R}}==

This can be done with a simple function.

Because R evaluates function arguments lazily, "expr" is never evaluated unless "cond" evaluates to true.

If you do not want to state "do.if" first, you can define an infix operator (any function whose name is bracketed in percent signs is treated as an infix operator), however custom infix operators have higher precedence than comparisons, so will usually require putting parentheses around the test.

=={{header|Racket}}==

However, two <tt>.</tt>s allow infix notation in some cases.

#lang racket

(when #t (displayln "true"))

(set! a 5)

(a . set! . 6)

=={{header|Raku}}==

(formerly Perl 6)

Like all Perls, Perl 6 has statement modifiers:

say 'Wow! Lucky Guess!' if $guess == 6; # Inverted

unless $guess == 6 { say "Huh! You Guessed Rong!" } # Traditional

Perl also inverts the syntax of loops:

--$i while $i;

for 1..10 { .say if $_ %% 2 }

Perl 6 has a system of metaoperators that modify the characteristics of normal operators. Among these is the <tt>R</tt> metaoperator, which is able to reverse the arguments of most infix operators (including user-defined ones).

So a reversed assignment is easy to write:

Since, much like list operators, assignment loosens the precedence of the following expression to allow comma lists, reverse assignment of a list requires parens where the normal assignment would not:

However, generally in that case you'd use a feed operator anyway, which is like an object pipe, but unlike Unix pipes works in either direction:

We think this is much more readable than a reversed assignment.

One other interesting inversion is the ability to put the conditional of a repeat loop at either end, with identical test-after semantics:

$_ = prompt "Gimme a number: ";

} until /^\d+$/;

repeat until /^\d+$/ {

$_ = prompt "Gimme a number: ";

This might seem relatively useless, but it allows a variable to be declared in the conditional that isn't actually set until the loop body:

$answer = prompt "Gimme an answer: ";

This would require a prior declaration (and two extra semicolons, horrors)

if written in the non-inverted form with the conditional at the bottom:

repeat {

$answer = prompt "Gimme an answer: ";

You can't just put the <tt>my</tt> on the <tt>$answer</tt> in the block because the conditional is outside the scope of the block, and would not see the declaration.

SIGNAL {ON|OFF} someCondition {name}

</pre>

signal on syntax

a=7

say 'the REXX statement number is: ' sigL " and the REXX source is:"

say sourceLine(sigL)

'''output'''

<pre>

These always check the condition ''before'' running the statement.

if n < 0 then raise ArgumentError, "negative n" end

raise ArgumentError, "negative n" if n < 0

# Another way to empty an array, printing each element.

until ary.empty? do puts ary.shift end

One can also modify a compound statement, as in <code>(warn "cannot fork"; exit 1) unless Process.respond_to? :fork</code>.

=={{header|Scala}}==

val raining = true

val needUmbrella = raining

println(s"Do I need an umbrella? ${if (needUmbrella) "Yes" else "No"}")

=={{header|Sidef}}==

var raining = true;

[false]»(\var needumbrella);

if (raining==true) {needumbrella=true};

{needumbrella=true} -> if (raining==true);

=={{header|Swift}}==

Inverted syntax can be done with custom operators

infix operator ! {}

// Inverted using a custom operator

=={{header|Tcl}}==

Copied verbatim from do.tcl, a part of tcllib's control package.

# do.tcl --

#

package require control

control::do {set i 0; puts "hello world"; incr i} until {$i > 0}

A more radical and probably ill-advised approach is to use the above

and modify the default tcl unknown procedure along these lines:

rename unknown __unknown

proc unknown {args} {

% {set i 0; puts "hello world"; incr i} until {$i > 0}

hello world

=={{header|TI-83 BASIC}}==

Assignment uses inverted syntax.

=={{header|Wortel}}==

The <code>~</code> operator reverse the arguments of the next operator.

:a expr

; expr = a

@if cond expr

; if expr cond

=={{header|Wren}}==

Again, simulating inverted syntax with assignment is not possible.

construct new(b) {

if (!(b is Bool)) Fiber.abort("B must be a boolean")

raining = false

needUmbrella = itrue.iff(raining)

{{out}}

=={{header|Z80 Assembly}}==

Syntax on the Z80 is very rigid; macros notwithstanding there is very little support for inverted syntax. However, since the CPU is little-endian, you can store 16-bit data as a word or 2 bytes:

Both of the above are equivalent.

It is also useful to "unwind" computations so they are easier to read

but not require any temp vars.