Extend your language: Difference between revisions

Pick the syntax which suits your language. The keywords 'else1' and 'else2' are just examples. The new conditional expression should look, nest and behave analogously to the language's built-in 'if' statement.

=={{header|ABAP}}==

WHEN condition1istrue = abap_true THEN firstconditionistrue

WHEN condition2istrue = abap_true THEN secondconditionistrue

ELSE noconditionistrue ).

=={{header|6502 Assembly}}==

Although new opcodes cannot be created, they can be combined in ways to re-create opcodes on other architectures. Expanding the language is typically accomplished with macros or, if the hardware allows, self-modifying code.

This is an (admittedly messy) implementation of the double-conditional branch. Unfortunately due to the nature of the processor each branch type needs its own macro. For brevity's sake only <code>BEQ</code> will be displayed here. The rest can be created with simple copy-pasting and substitution.

 

; input:

; \1 = first condition. Valid addressing modes: immediate, zero page, or absolute.

.doublefalse:

JMP \6 ;both are false

 

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

I'm using VASM as my assembler, which does support macros, however, the use of macros is somewhat limited, as it's not easy to generalize to all data lengths, conditions, etc. A macro parameter can only take the place of an instruction argument, not an instruction itself. So I'd have to use separate macros for all the possible branch types. Thankfully, addressing modes can be generalized, so I don't have to write separate macros for each.

 

;input: 1 = first param (can be any addressing mode compatible with CMP)

; 2 = second param (used for condition 1)

move.b #1,d0

\@done:

=={{header|Ada}}==

 

 

procedure Test_If_2 is

end case;

end loop;

 

{{out}}

Given agda's lack of a prelude, I have decided to define my own boolean type. That is however not necessary if you use, say, stdlib.

 

 

data Bool : Set where

example : Bool

example = if2 true , false then true else1 false else2 true else false

 

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

PRIO ALSO = 1;

OP ALSO = ( BOOL a, b )INT: IF a AND b THEN 1 ELIF a THEN 2 ELIF b THEN 3 ELSE 4 FI;

, print( ( "second: only b is TRUE", newline ) )

, print( ( "neither: a and b are FALSE", newline ) )

 

=={{header|ALGOL W}}==

In Algol W, a statement can be used as a parameter to a procedure that expects a procedure with no parameters (similarly, an expression can be passed for a parameterless procedure that returns the appropriate type).

% executes pBoth, p1, p2 or pNeither %

% depending on whether c1 and c2 are true, c1 is true, c2 is true %

)

end

 

=={{header|Arturo}}==

case []

when? [and? cond1 cond2] -> do both

[print "only first"]

[print "only second"]

{{out}}

See also [[#OCaml|OCaml]] and [[#Standard_ML|Standard ML]].

 

 

fn

func (false, true);

func (false, false)

{{out}}

<pre>$ patscc extend_your_language.dats && ./a.out

This task requires syntax different from the <code>if</code> keyword in C. For example:

 

*

* if2 (firsttest, secondtest

case 3: bothfalse; break;\

}

 

Example application:

 

#include <stdio.h>

#include <stdlib.h>

}

return 0;

 

Example invocation:

 

cc exten.c -o exten

3: a number

b: not a number

: not a number

 

The following is probably easier to read, although <code>fi2</code> is funny looking however you slice it. On the other hand, this kind of macros are unquestionably in the "bad" category.

 

#define if2(a, b) switch(((a)) + ((b)) * 2) { case 3:

 

return 0;

 

=={{header|C sharp|C#}}==

 

using System;

}

 

{{out| Program Output}}

<pre>

=={{header|Clay}}==

 

cond2:Bool,

both,

return neither;

}

 

=={{header|Clojure}}==

Clojure being a LISP has macros.

 

(defmacro if2 [[cond1 cond2] bothTrue firstTrue secondTrue else]

`(let [cond1# ~cond1

(if cond1# (if cond2# ~bothTrue ~firstTrue)

(if cond2# ~secondTrue ~else))))

 

<pre>

 

An alternative, cleaner way using case macro of Clojure:

(defmacro if2

[cond1 cond2 both-true first-true second-true both-false]

[false true] ~second-true

[false false] ~both-false))

 

<pre>

=={{header|COBOL}}==

Cobol already has a multiple-if:

EVALUATE EXPRESSION-1 ALSO EXPRESSION-2

WHEN TRUE ALSO TRUE

DISPLAY 'Neither is true.'

END-EVALUATE

(Of course, Cobol is also inherently non-extensible.)

 

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

 

(let ((res1 (gensym))

(res2 (gensym)))

(,res1 ,first)

(,res2 ,second)

 

Interactive tests to validate if2.

=={{header|Coq}}==

Coq allows "[https://coq.inria.fr/refman/user-extensions/syntax-extensions.html syntax extensions]":

Notation "A /\ B" := (and A B)

 

=={{header|D}}==

D features lazy arguments, which can be used for this task.

 

lazy T1 first,

lazy T2 both,

test(3 > 4, 3 > 4);

test(3 > 4, 1 < 2);

{{out}}

<pre>first

First example:

 

procedure Check(Condition1: Boolean; Condition2: Boolean)

begin

else

NoConditionIsTrue;

 

Second example:

 

procedure Check(Condition1: Boolean; Condition2: Boolean)

begin

SecondConditionIsTrue

else NoConditionIsTrue;

 

In both examples if Condition1 and/or Condition2 are Booleans you can omit the '= True' (not when for instance comparing Integers: a = 1)

Execution of the proper lambda can be realized by manipulating the return stack with <code>(</code> (move from data stack to return stack) <code>)</code> (move from return stack to data stack) in two nested if-blocks. Usually the start locations of lambdas and locations of operators like <code>?</code> are stored on the return stack.

 

{ [ top cond. = true ][ top cond. = false ]}

{ [ 2nd = true ][2nd = false ] [ 2nd = true ][ 2nd = false] }

[(((([[)))!)))%%%%%][)))))!)%%%%%]?][[))))!))%%%%%][))))))!%%%%%]?]?]⇒¿

 

Example program:

 

 

Resulting output of the example program:

The control structure is built up and then executed by chained method calls (similar to jQuery) starting from the <var>controlName</var> object, one for each {}, each of which takes a closure as a parameter. The first closure actually returns the parenthesized <var>args</var> evaluated and a closure for the first {}, which the args are in scope for; the closures for all following {} do not have the <var>args</var> in scope.

 

 

def makeIf2Control(evalFn, tf, ft, ff) {

}

}

 

The internal expansion of the "if2" block above is:

 

[[a, b], fn {

println("both")

}).else__control_0(fn {

println("neither")

 

=={{header|EchoLisp}}==

'''define-syntax''' and '''define-syntax-rules''' are here to extend the language

(define-syntax-rule

(if2 cond1 cond2 both cond1-only cond2-only none) ;; new syntax

→ "positive and inexact"

 

 

=={{header|Emacs Lisp}}==

The same macro that works in Common Lisp will work in Emacs Lisp for this problem:

(defmacro if2 (cond1 cond2 both first second &rest neither)

(let ((res1 (gensym))

(,res2 ,second)

(t ,@neither)))))

{{Out}}

Interactive tests to validate if2.

 

=={{header|F_Sharp|F#}}==

// Extend your language. Nigel Galloway: September 14th., 2021

type elsetf=TF

elseft (fun()->printfn "ft")

elseff (fun()->printfn "ff")

{{out}}

<pre>

</pre>

Looking at some possible errors found by the compiler:

if2 (13<23) (23<42) (fun()->printfn "tt")

elseff (fun()->printfn "tf")

elseft (fun()->printfn "ft")

elseff (fun()->printfn "ff")

{{out}}

<pre>

'elseff'

</pre>

if2 (13<23) (42<23) (fun()->printfn "tt")

elsetx (fun()->printfn "tf")

elseft (fun()->printfn "ft")

elseff (fun()->printfn "ff")

{{out}}

<pre>

=={{header|Factor}}==

Not too hard, as long as you're not worried about choking to death on stack effects:

[ [ if ] curry curry ] 2bi@ if ; inline

( scratchpad ) 3 [ 0 > ] [ even? ] bi [ 0 ] [ 1 ] [ 2 ] [ 3 ] 2ifte .

 

=={{header|Fennel}}==

;; The "`" and "," characters are used to construct a template for the macro.

(macro if2 [cond1 cond2 both first second none]

(test-if2 true false) ;"first"

(test-if2 false true) ;"second"

 

=={{header|Forth}}==

Control structures in Forth are just IMMEDIATE words, which flags them to be run at compile time. POSTPONE invokes the compile-time semantics of words instead of executing them.

 

: BOTH postpone IF postpone IF ; immediate

NEITHER drop ;

: fizzbuzz ( n -- ) 0 do i 1+ fb loop ;

 

=={{header|Fortran}}==

Fortran does not offer language extension facilities except in the form of allowing a programmer to define subroutines and especially functions, that extend the collection of library functions and which could look a bit like a new statement form if viewed sympathetically. Similarly, there is no built-in pre-processor (as in pl/i) which would enable the definition of what could look like an additional statement form. So, you're stuck with something like <code>call DIRECTWRITE(F,FMT,B,X + 7)</code> in place of <code>WRITE (F,FMT) B,X + 7</code> where one is to pass over the appearance of "call" and disregard the placement of the ")" symbol.

 

INTEGER IA,IB !As the default integer size.

EQUIVALENCE (IA,A),(IB,B) !So, this will cause no overlaps.

 

999 CONTINUE

Which is to say that prior to Fortran 66 there were no LOGICAL variables, so one employed integer variables and used integer arithmetic with + and * for .OR. and .AND. on variables with the obvious values of zero and one - though additional values may be considered for more complex state collections with more complex calculations in mind. This involves re-interpreting what might appear to be integer arithmetic, but is not much of an extension to the language. With the introduction of LOGICAL variables and their associated operators, the results could be unexpected, as shown in the third lot of output:

<pre>

TT -1 -1 -3

</pre>

LOGICAL A,B !These.

IF2 = 0 !Wasted effort if A is true.

IF (A) IF2 = 2 !But it avoids IF ... THEN ... ELSE ... END IF blather.

IF (B) IF2 = IF2 + 1 !This relies on IF2 being a variable. (Standard in F90+)

CASE(B"00"); WRITE (6,*) "Both false."

CASE(B"01"); WRITE (6,*) "B only."

CASE(B"10"); WRITE (6,*) "A only."

CASE(B"11"); WRITE (6,*) "Both true."

 

But there is no extension to the allowed syntax, as such.

 

Note, as of 2019‑09‑04 this construct works only with a trunk FPC version.

var

tuple: record

end;

end;

 

=={{header|FreeBASIC}}==

 

#Macro If2(condition1, condition2)

Print

Print "Press any key to quit"

 

{{out}}

However, it's far less elegant. This is because, in Go, function arguments cannot be passed outside the method's parentheses and must be preceded by the func keyword.

 

 

import "fmt"

fmt.Println("a = 1 and b <> 3")

})

 

{{out}}

Expressions in Haskell are not evaluated until they are needed, so ordinary functions can be control structures.

 

if2 p1 p2 e12 e1 e2 e =

if p1 then

 

main = print $ if2 True False (error "TT") "TF" (error "FT") (error "FF")

 

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

(PDCO) may be defined and used. Here is an example:

 

if2 { (A[1] = A[2]), (A[3] = A[4]), # Use PDCO with all three else clauses

write("1: both true"),

else if @A[2] then |@\A[5]

else |@\A[6]

 

and some sample runs:

Idris provides the [http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html#laziness Lazy] data type, which makes the computation of a parameter lazy.

 

if2 True True v _ _ _ = v

if2 True False _ v _ _ = v

if2 False True _ _ v _ = v

 

=={{header|Inform 7}}==

=== Statement ===

Inform 7 has two syntaxes for flow control blocks. Unfortunately, the newer indentation-based syntax only works with the built-in flow control statements, but it's possible to define new flow control statements using the older begin...end syntax:

To else1 -- in if2: (- } until (1); 2: do { -).

To else2 -- in if2: (- } until (1); 1: do { -).

 

Note that the "else0" part must be given, although "else1" and "else2" are optional. Demonstration:

 

When play begins:

else0;

say "neither";

 

=== Text substitution ===

(- switch (({c1})*2 + ({c2})) { 3: -).

To say else1 -- continuing if2: (- 2: -).

To say else2 -- continuing if2: (- 1: -).

To say else0 -- continuing if2: (- 0: -).

 

Demonstration:

 

When play begins:

 

=={{header|J}}==

Here, we extend our language by defining a conjunction <code>if2</code> which consumes two nouns and produces a verb:

 

'`b1 b2'=. n

m@.(b1 + 2 * b2) f.

 

Example use:

 

f1=: [: smoutput 'first option: ' , ":

f2=: [: smoutput 'second option: ' , ":

both options: 2

first option: 3

 

That said, note that a switch statement which combines the boolean conditions as a base 2 number might be more convenient.

Java lambdas can go a long way towards allowing the implementation of lazy "branches", as this example shows.

 

public class If2 {

 

}

}

 

Usage:

 

import static If2.if2;

class Main {

}

}

 

To allow optional else branches, and perhaps a more readable syntax with named branches, a more Object-Oriented approach can be used:

 

public class If2 {

private final boolean firstCondition;

}

}

 

Usage (imports and main class ommited for brevity):

 

// prints "both true"

if2(true, true)

print("none true");

});

 

=={{header|Julia}}==

Julia has very powerful macros for metaprogramming. Code can be handled as a type of data in Julia. Julia macros are defined similarly to other functions, but are called with an '@' prior to the macro name, in order to distinguish macro calls from other function calls.

const CSTACK1 = Array{Bool,1}()

const CSTACK2 = Array{Bool,1}()

 

@elseifneither(begin println("neither") end)

{{output}}<pre>

all

=={{header|Kotlin}}==

Kotlin does not have macros or the like but, using a combination of chained functions and lambdas, it's possible to create something which closely resembles a language extension:

 

data class IfBoth(val cond1: Boolean, val cond2: Boolean) {

println("a = 1 and b <> 3")

}

 

{{out}}

=={{header|Lua}}==

Stricly speaking, Lua has no such capabilities. However, it could <i>perhaps</i> be approximated with a bit of trickery. This gets rather close to the suggested syntax, except for the long brackets. ("then2" is for parity with existing syntax)

-- not to be taken seriously, ridiculous, impractical, esoteric, obscure, arcane ... but it works

 

 

end

{{out}}

<pre>i=1 j=1

Lambdatalk comes with macros translating regular expressions into lambdatalk expressions

 

{macro \{if2 (true|false|\{[^{}]*\}) (true|false|\{[^{}]*\})\}

to {if {and $1 $2}

{if2 {> 1 2} {< 3 4}} -> the second is true

{if2 {> 1 2} {> 3 4}} -> neither are true

 

=={{header|langur}}==

We could use the nxor (logical equivalence) operator to test truthiness.

 

case true: ... # both true

case true, false: ... # first true, second false

case false, true: ... # first false, second true

default: ... # both false

 

To test directly for Boolean values (not truthiness), we could use the default == comparison.

 

case true: ... # both true

case true, false: ... # first true, second false

case null, _: ... # first null, second irrelevant

default: ... # other

 

=={{header|Lasso}}==

Lasso doesn't allow you to define new keywords for the parser, but it does allow you to achieve a similar effect using captures and givenblock as illustrated below.

 

 

define if2 => type {

define else1 => thread_var_get(::if2)->else1 => givenblock

define else2 => thread_var_get(::if2)->else2 => givenblock

 

Example use:

 

ifboth => {

bothConditionsAreTrue

noConditionIsTrue

}

 

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

We can use nested if2 with same ctrl value, because ctrl programmed each time before a part block.

 

module if2 {

over 3 : read &c

Print "ok"

 

 

=={{header|m4}}==

See also [[#Plain_TeX|Plain TeX]].

 

 

#

ifelse2(1,1,2,-2,`exprxy',`exprx',`expry',`expr')

ifelse2(1,-1,2,2,`exprxy',`exprx',`expry',`expr')

 

{{out}}

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

Mathematica is not precisely a Lisp, but it can easily construct macros by holding the arguments to a function:

If2[test1_, test2_, condBoth_, cond1_, cond2_, condNone_] := With[

{result1 = test1,

True, condNone]];

SetAttributes[If2, HoldAll];

 

Example usage (note that the tests are evaluated only once per call):

x = 0;

If2[Mod[(++x), 2] == 0, Mod[x, 3] == 1, Print["Both: ", x], Print["First: ", x], Print["Second: ", x], Print["Neither: ", x]];

If2[Mod[(++x), 2] == 0, Mod[x, 3] == 1, Print["Both: ", x], Print["First: ", x], Print["Second: ", x], Print["Neither: ", x]];

If2[Mod[(++x), 2] == 0, Mod[x, 3] == 1, Print["Both: ", x], Print["First: ", x], Print["Second: ", x], Print["Neither: ", x]];

{{out}}

<pre>

In min, <code>if</code> is simply a higher-order function that takes three quotations: a predicate and two branches. Likewise, <code>if2</code> is simply a higher-order function that takes six quotations: two predicates and four branches. No metaprogramming required.

{{works with|min|0.27.1}}

:none :two :one :both -> :r2 -> :r1

(

("false")

if puts! ;true

 

=={{header|Morfa}}==

Morfa's operator defining and overloading can be employed to provide more natural syntax for expressing an <tt>if2</tt> "statement".

import morfa.base;

 

println("none true");

};

 

=={{header|Nemerle}}==

In file "if2macro.n":

// point of interest: the when keyword and && operator inside the macro definition are macros themselves

 

when(!($cond1) && !($cond2)) {$bodyFF};

]>

Compile with:

<pre> ncc -r Nemerle.Compiler.dll -t:dll if2macro.n -o if2macro.dll</pre>

In file useif2.n:

using System.Console;

 

Write("You're unhappy, cheer up");

}

Compile with:<pre>ncc -r if2macro.dll useif2.n</pre>

 

=={{header|NewLISP}}==

 

 

(define-macro (if2:if2 cond1 cond2 both-true first-true second-true neither)

> (if2 false false 'bothTrue 'firstTrue 'secondTrue 'else)

else

 

=={{header|Nim}}==

proc newIfElse(c, t, e: NimNode): NimNode {.compiletime.} =

echo "2"

else3:

 

=={{header|OCaml}}==

The same goes for pattern matchers in Lisps, such as the widely used public domain pattern matcher for Scheme.

 

 

let myfunc pred1 pred2 =

myfunc true false;;

myfunc false true;;

 

{{out}}

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

Of course the language can be extended with GP functions (starting with version 2.4.2, these are closures).

if(c1,

if(c2,tt,tf)

if(c2,ft,ff)

)

 

GP can also be extended by adding C code directly to Pari:

if2(GEN c1, GEN c2, GEN tt, GEN tf, GEN ft, GEN ff)

{

else

return tt ? closure_evalgen(tt) : gnil;

 

This function, when compiled to the file <code>if2.gp.so</code>, can be loaded into GP with the following commands:

Alternately, add these lines into the C course and run through gp2c-run:

GP;install("if2","GGDEDEDEDE","if2","./if2.gp.so");

GP;addhelp(if2, "if2(a,b,{seq1},{seq2},{seq3},{seq4}): if a is nonzero and b is nonzero, seq1 is evaluated; if a is nonzero and b is zero, seq2 is evaluated; if a is zero and b is nonzero, seq3 is evaluated; otherwise seq4. seq1 through seq4 are optional.");

 

=={{header|Perl}}==

Closures enable user-defined control structures, but the syntax is not always identical to that of built-in control structures. This example is a start, but needs improving.

 

#!/usr/bin/perl

use warnings;

 

test_bits $_ for 0 .. 7;

 

Sample run:

 

msl@64Lucid:~/perl$ ./if2

Testing 0: Neither bit is set

Testing 7: Both bits 0 and 1 are set

msl@64Lucid:~/perl$

 

=={{header|Phix}}==

Phix does not support macro programming. Generally I would suggest one of the following

<span style="color: #008080;">switch</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">condition1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">condition2</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">case</span> <span style="color: #0000FF;">{</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">}:</span>

<span style="color: #008080;">case</span> <span style="color: #0000FF;">{</span><span style="color: #004600;">false</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">}:</span>

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

or

<span style="color: #008080;">function</span> <span style="color: #000000;">if2</span><span style="color: #0000FF;">(</span><span style="color: #004080;">bool</span> <span style="color: #000000;">c1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">c2</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">c1</span><span style="color: #0000FF;">*</span><span style="color: #000000;">10</span><span style="color: #0000FF;">+</span><span style="color: #000000;">c2</span>

<span style="color: #008080;">case</span> <span style="color: #000000;">00</span><span style="color: #0000FF;">:</span>

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

or

<span style="color: #008080;">enum</span> <span style="color: #000000;">BOTH</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b11</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">FIRST</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">SECOND</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b01</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">NEITHER</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b00</span>

<span style="color: #008080;">elsif</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">=</span><span style="color: #000000;">NEITHER</span> <span style="color: #008080;">then</span>

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

I can accept that those could all be deemed cheating (and that the last does not look anywhere near as nice as I hoped it would).

 

Next add new keywords. Find the last use of tt_stringF in pttree.e and add them. We do not know

the ttidx values yet, so just duplicate the last one(5200)

<span style="color: #008080;">global</span> <span style="color: #008080;">constant</span> <span style="color: #000000;">T_if2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5200</span> <span style="color: #000000;">tt_stringF</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"if2"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_if2</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">global</span> <span style="color: #008080;">constant</span> <span style="color: #000000;">T_else1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5200</span> <span style="color: #000000;">tt_stringF</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"else1"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_else1</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">global</span> <span style="color: #008080;">constant</span> <span style="color: #000000;">T_else2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">5200</span> <span style="color: #000000;">tt_stringF</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"else2"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_else2</span><span style="color: #0000FF;">)</span>

Then run p p and it will tell you what they should be

<pre>

</pre>

Update the values and rebuild the compiler using "p -cp" (approx 10 seconds), then we can add the latter two to the block terminators (in pmain.e):

<span style="color: #000080;font-style:italic;">--constant T_endelseelsif = {T_end,T_else,T_elsif,T_case,T_default,T_fallthru,T_fallthrough}</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">T_endelseelsif</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">T_end</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_else</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_else1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_else2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_elsif</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_case</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_default</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_fallthru</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_fallthrough</span><span style="color: #0000FF;">}</span>

Admittedly the next part is non-trivial. Not really worthwhile showing here, the distribution

includes the file demo\rosetta\if2.txt which contains a DoIf2() procedure (120 lines) that

 

Lastly, that would need to be hooked in, find the DoSwitch call (again in pmain.e) and insert after it:

<span style="color: #008080;">elsif</span> <span style="color: #000000;">ttidx</span><span style="color: #0000FF;">=</span><span style="color: #000000;">T_if2</span> <span style="color: #008080;">then</span> <span style="color: #000000;">DoIf2</span><span style="color: #0000FF;">()</span>

 

Recompile Phix (p -cp, approx 10s) and test.

Obviously, while I have subsequently removed it, I have tried this myself and it worked fine:

<span style="color: #008080;">for</span> <span style="color: #000000;">N</span><span style="color: #0000FF;">=</span><span style="color: #000000;">10</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20</span> <span style="color: #008080;">do</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;">"%d is "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">N</span><span style="color: #0000FF;">)</span>

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

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

The equivalent changes that would be needed for pwa/p2js are left as an exercise for the reader, as above it would be largely a matter of figuring out what "switch" does and inserting a modified copy of that.

{{Out}}

 

=={{header|PHL}}==

 

import phl::lang::io;

println("Not this!");

];

 

=={{header|PicoLisp}}==

 

(de if2 "P"

(if (eval (car "P"))

(eval (cadddr "P"))

Usage:

<pre>(if2 (condition1isTrue) (condition2isTrue)

See also [[#m4|m4]].

 

{\if#1#2\if#3#4#5\else#6\fi\else\if#3#4#7\else#8\fi\fi}

 

\message{\iftwo{1}{-1}{2}{-2}\both\elsefirst\first\elsesecond\second\elseneither\neither\owtfi}

 

{{out}}

<pre>$ tex extend_your_language.tex

 

=={{header|PowerShell}}==

function When-Condition

{

}

}

Full syntax:

When-Condition -Test1 (Test-Path .\temp.txt) -Test2 (Test-Path .\tmp.txt) `

-Both { "both true"

} -Neither { "neither true"

}

{{Out}}

<pre>

</pre>

Alternate syntax:

Set-Alias -Name if2 -Value When-Condition

 

} { "neither true"

}

{{Out}}

<pre>

Note, however, that this is not a syntax extension. The following example is included merely for the sake of completeness.

 

 

if (c1 := a == 1) and (c2 := b == 3):

print('a <> 1 and b = 3')

else:

 

=={{header|Quackery}}==

Quackery is of the Forth family of languages and related to the Lisp family by marriage, so extensible control structures are a given. To this end it is equipped with ''meta-control'' words (the words in the code wrapped in reverse brackets) which grant control flow properties to words that use them. Code is given here for two possible syntaxes of a four-way IF.

 

 

[ not swap not 1 << |

false true task.2

false false task.2

 

{{out}}

It is not possible to extend the language by adding keywords or creating macros. This kind of behaviour can be faked be creating functions that take expressions and evaluating them. (The switch and ifelse functions are existing examples.)

 

if2 <- function(condition1, condition2, both_true, first_true, second_true, both_false)

{

eval(expr)

}

 

A test example:

for(x in 1:2) for(y in letters[1:2])

{

))

}

 

A variation that brings the syntax more in line with that described in the task is

if2 <- function(condition1, condition2, expr_list = NULL)

{

eval(cl[[cl_name]])

}

 

The usage here is modified to

for(x in 1:2) for(y in letters[1:2])

{

)))

}

 

=={{header|Racket}}==

Racket, like other Schemes, makes this kind of thing almost trivial:

 

#lang racket

;; define a new syntax

(try 10 1) ; Second is small

(try 10 10) ; Neither is small

 

But as usual, Racket takes this much more seriously. For example, here is how the same looks in an upcoming infix-style language in Racket:

 

This solution is hygienic in both lexical and dynamic variables; the only caveat is that the user's program must avoid the dynamic variable being used by the implementation of conditional, <tt>$*IF2</tt>. This does not seem like a great hardship. (The conditionals will also nest correctly since that's how dynamic variables behave.)

 

my &if-both = -> &x { x if @*IF2 eq (True,True) }

}

 

{{out}}

<pre>Got both

 

'''Usage example:'''

 

 

/*an example of a DO structure for the first clause: */

 

parse arg bot top . /*obtain optional arguments from the CL*/

if bot=='' | bot=="," then bot=10 /*Not specified? Then use the default.*/

if.11= if.10 & if.01 /* " " case " 11 */

if.00= \(if.10 | if.01) /* " " " " 00 */

'''output'''

<pre>

 

=={{header|Ring}}==

# Project : Extend your language

 

ok

see nl

Output:

<pre>

=={{header|Ruby}}==

Ruby uses a hopelessly egocentric combinator (aka a combinator in which Kx = K for all x) and anonymous classes inherited from that combinator to do the job:

class HopelesslyEgocentric

def method_missing(what, *args) self end

end.new

end

Usage:

print "%5s, %5s => " % [cond1, cond2]

if2(cond1, cond2) do

puts "neither is true"

end

{{out}}

<pre>

 

=={{header|Rust}}==

macro_rules! if2 {

($cond1: expr, $cond2: expr

=> println!("neither were true")

)

 

=={{header|Scala}}==

 

Defining a new control construct:

| def else1(xt: => A) = new {

| def else2(yt: => A) = new {

| }

if2: [A](x: => Boolean)(y: => Boolean)(xyt: => A)java.lang.Object{def else1(xt: => A): java.lang.Object{def else2(yt: =>

 

Usage:

| 1

| } else1 {

| "Zoro"

| }

 

=={{header|Scheme}}==

(define-syntax if2

(syntax-rules ()

(if c2 both-true first-true)

(if c2 second-true none-true))))))

 

=={{header|Seed7}}==

Seed7 allows the definition of statement [http://seed7.sourceforge.net/manual/syntax.htm syntax] and semantic.

 

$ syntax expr: .if.().().then.().else1.().else2.().else3.().end.if is -> 25;

writeln("error FALSE FALSE");

end if;

 

=={{header|Shen}}==

Like most Lisps, this is trivial in Shen.

[branch-if Cond1 Cond2 Both Fst Snd None] ->

[if Cond1

[if Cond2 Both Fst]

Example:

(define try

X Y -> (branch-if (integer? X)

 

(map (/. X (do (print X) (nl)))

 

=={{header|Sidef}}==

method then(block) { # both true

if (cond1 && cond2) {

}.else {

say "else"

=={{header|Smalltalk}}==

True method:&sup1; &sup2;

"I know for sure, that I am true..."

False method:

"I know for sure, that I am false..."

 

You can now write:

ifBoth:[ 'both' printCR]

ifFirst:[ 'only first' printCR ]

ifSecond:[ 'only second' printCR ]

 

Note 1: you may have noticed, that the normal "ifTrue:" methods look very similar. That is because they are implemented exactly the same way - in Smalltalk, there is no syntax; all is done via this kind of method dispatch (in this case to the true or false object).<br>Note 2: I could have named the keywords "else1:", "else2:", "else:", but in Smalltalk it is good practice to give them more descriptive names).

It would also be possible to define a dummy class named "If2" and there a class method (aka static method).

<br>But I'd like to mention that this is considered very bad style (polluting the class namespace with such stuff):

when:cond1 or:cond2 ifBoth:both ifFirst:first ifSecond:scnd ifNone:none

^ cond1 ifTrue:[

] ifFalse:[

cond2 ifTrue:scnd ifFalse:none

Now, you can write:

ifBoth:[ 'both' printCR]

ifFirst:[ 'only first' printCR ]

ifSecond:[ 'only second' printCR ]

 

=={{header|Standard ML}}==

See also [[#ATS|ATS]] and [[#OCaml|OCaml]].

 

 

fun myfunc (pred1, pred2) =

myfunc (true, false);

myfunc (false, true);

 

{{out}}

=={{header|Tcl}}==

The core of Tcl's language-level extensibility are the <code>uplevel</code> and <code>upvar</code> commands, which respectively allow execution of arbitrary code in the caller's context and provide safe access to variables in the caller's context. To create an <code>if2</code>, only <code>uplevel</code> is required (together with <code>list</code> which does substitution-safe script generation as a side-effect):

# Must evaluate both conditions, and should do so in order

set c1 [uplevel 1 [list expr $cond1]

uplevel 1 $bothFalseBody

}

Demonstrating:

puts "1 and 2"

} {

} {

puts "neither 1 nor 2"

Which produces this output:

<pre>1 but not 2</pre>

=== Condition-free form ===

It's also possible to write this without any use of <code>if</code> at all, through the careful selection of variable names:

# Must evaluate both conditions, and should do so in order

# Extra negations ensure boolean interpretation

# Use those values to pick the script to evaluate

uplevel 1 [set body$c1$c2]

This behaves exactly as above, so shall not be repeated here.

=== Other language extension forms ===

Tcl includes very strong support for language extension. For example, consider this code which implements a integer looping command:

upvar 1 $varName var

for {set var $lowerBound} {$var <= $upperBound} {incr var} {

uplevel 1 $body

}

That implements, in a few lines of code, a new looping construct that does integer iteration and which supports both <code>break</code> and <code>continue</code>, as any loop should. The loop variable is “owned” by the context which calls the loop, and the loop body can access all local variables. It's all also completely safe against complex substitutions. Here's an example of use:

loop i 1 $M {

loop j 1 $N {

}

}

Output:

<pre>

{{trans|CommonLisp}}

 

(let ((res1 (gensym))

(res2 (gensym)))

(,res1 ,first)

(,res2 ,second)

 

=={{header|UNIX Shell}}==

 

{{works with|Bourne Shell}}

if eval "$1"; then

if eval "$2"; then eval "$3"; else eval "$4"; fi

if eval "$2"; then eval "$5"; else eval "$6"; fi

fi

 

echo both 1 and 2

' '

' '

echo neither 1 nor 2

 

==={{header|es}}===

{{trans|Tcl}}

# Must evaluate both conditions, and should do so in order.

# Negation ensures a boolean result: a true condition becomes

$(body$c1$c2)

}

 

echo 1 and 2

} {

} {

echo neither 1 nor 2

 

=={{header|Ursala}}==

Identifiers can't contain digits, so the function is named <code>iftwo</code>.

 

"p"?(

"q"?("both","justp"),

The type of <code>iftwo</code> is that of a function taking a pair of predicates and

returning a function that takes a list of four functions. A function of the form

{{trans|Kotlin}}

Like Kotlin Wren does not have macros but, using a combination of chained functions and methods, it's possible (if you squint a little) to create something which closely resembles a language extension.

construct new(cond1, cond2) {

_cond1 = cond1

}.elseFirst {

System.print("a == 1 and b <> 3")

 

{{out}}

=={{header|XBS}}==

In XBS you are allowed to define custom syntax. The only real purpose for this is quick development or testing.

newsyntax

@in:CH

equalsOneOrTwo(2);

equalsOneOrTwo(3);

{{out}}

<pre>

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

The language can only really be extended using macros, since there's no way to add your own commands. This is a simple template for a 4 way branch. It's not the most elegant method, but it gets the job done.

jr nz,B_False

cp c

 

done:

 

 

The only way to formally create additional commands for ZX Spectrum Basic is by attaching an Interface 1 and defining the command in machine code. However, we can work with the fact that boolean comparisons are evaluated numerically by defining a new function with the value table.

 

20 FOR x=1 TO 20

30 LET a=(x/2)=INT (x/2): REM comparison 1

80 PRINT x;" is divisible by 3": GO TO 100

90 PRINT x;" is divisible by 2 and 3"

{{out}}

<pre>1 is not divisible by 2 or 3