Generic swap

From Rosetta Code

Many statically typed languages provide a generic programming capability. In C++ this capability is called templates. In Ada it is called generics. Such generic capabilities are simply the natural approach to programming for dynamically typed languages.

This task asks you to create a generic swap method that can be used for a wide variety of data types. If your solution language is statically typed please describe the way your language provides genericity. (This is actually a simple example of Parametric Polymorphism)

Contents 1 Ada 2 ALGOL 68 3 AmigaE 4 AppleScript 5 AutoHotkey 6 Batch File 7 C 8 C++ 9 C# 10 Clojure 11 Common Lisp 12 ColdFusion 13 D 14 dc 15 E 16 Erlang 17 F# 18 Factor 19 Falcon 20 Fortran 21 Go 22 Groovy 23 Haskell 24 Icon and Unicon 24.1 Icon 24.2 Unicon 25 IDL 26 J 27 Java 28 JavaScript 29 Joy 30 Lisaac 31 Logo 32 Lua 33 M4 34 Mathematica 35 MAXScript 36 Metafont 37 Modula-3 38 Nial 39 OCaml 40 Octave 41 Oz 42 Perl 43 Perl 6 44 PHP 45 PicoLisp 46 PL/I 47 Pop11 48 PowerShell 49 Prolog 50 PureBasic 51 Python 52 REBOL 53 Ruby 54 Sather 55 Scala 56 Scheme 57 Seed7 58 Slate 59 Smalltalk 60 SNOBOL4 61 Standard ML 62 Tcl 63 ThinBASIC 64 TI-89 BASIC 65 Trith 66 Ursala 67 V 68 VBScript 69 Visual Basic

[edit] Ada

The generic parameters for an Ada generic procedure are defined in a procedure specification, while the algorithm is defined in a procedure body. The first code snippet is the procedure instantiation. The second code snippet is the procedure body.

generic
   type Swap_Type is private; -- Generic parameter
procedure Generic_Swap(Left : in out Swap_Type; Right : in out Swap_Type);
 
procedure Generic_Swap(Left : in out Swap_Type; Right : in out Swap_Type) is
   Temp : Swap_Type := Left;
begin
   Left := Right;
   Right := Temp;
end Generic_Swap;

[edit] ALGOL 68

A generic swap operator =:= was proposed in ALGOL Bulletin for standard ALGOL 68 so that the compiler could optimise the operation. However such an operator was not adopted and needs to be manually defined for each mode required.

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

MODE GENMODE = STRING;
 
GENMODE v1:="Francis Gary Powers", v2:="Vilyam Fisher";
 
PRIO =:= = 1;
 
OP =:= = (REF GENMODE v1, v2)VOID: (
  GENMODE tmp:=v1; v1:=v2; v2:=tmp
);
 
v1 =:= v2;
 
print(("v1: ",v1, ", v2: ", v2, new line))

Output:

v1: Vilyam Fisher, v2: Francis Gary Powers

[edit] AmigaE

The simpler way to write a swap is to use the Amiga E ability to return multiple values. All basic data type in Amiga E can be held by its LONG type, and complex data type (like lists) are indeed pointers (which fits into a LONG too); so, because of the fact that Amiga E is not strongly typed, this solution works for any type.

PROC swap(a,b) IS b,a
 
PROC main()
  DEF v1, v2, x
  v1 := 10
  v2 := 20
  v1, v2 := swap(v1,v2)
  WriteF('\d \d\n', v1,v2)           -> 20 10
  v1 := [ 10, 20, 30, 40 ]
  v2 := [ 50, 60, 70, 80 ]
  v1, v2 := swap(v1,v2)
  ForAll({x}, v1, `WriteF('\d ',x))  -> 50 60 70 80
  WriteF('\n')
  ForAll({x}, v2, `WriteF('\d ',x))  -> 10 20 30 40
  WriteF('\n')
ENDPROC

[edit] AppleScript

AppleScript has built-in support for swapping. This is generic and works for all combinations of data types.

set {x,y} to {y,x}

[edit] AutoHotkey

Swap(ByRef Left, ByRef Right)
{
    temp := Left
    Left := Right
    Right := temp
}

[edit] Batch File

Swap using pass-by-name

@echo off
setlocal enabledelayedexpansion
set a=1
set b=woof
echo %a%
echo %b%
call :swap a b
echo %a%
echo %b%
goto :eof
 
:swap
set temp1=!% class="re2">1!
set temp2=!% class="re2">2!
set %1=%temp2%
set %2=%temp1%
goto :eof

[edit] C

This has a restriction that a and b must be the same size. I think you could do better with preprocessor voodoo, but I am not enlightened enough to use it. I'm being cute here, so please don't hate me too much, and if a C guru could check it, I'd appreciate it (I tried it and it worked for me). It won't work for something like a linked list if you want all references to middle nodes to be translated, but it'll swap the heads just fine.

void swap(void *a, void *b, size_t size)
{
  char *ca, *cb;
  int i;
  ca = (char *)a;
  cb = (char *)b;
  for(i=0;i<size;*(ca+i)^=*(cb+i),*(cb+i)^=*(ca+i),*(ca+i)^=*(cb+i),++i);
}

You could also do it with a third buffer but then it wouldn't work for extremely large void pointers. It'd be faster to use a larger pointer than char *, but I wanted to keep it simple.

Another maybe better way is to use preprocessor macros and __typeof__ (supported by C89 at least)

#define Swap(X,Y)  do{ __typeof__ (X) _T = X; X = Y; Y = _T; }while(0)

Usage examples are:

#include <stdio.h>
 
#define Swap(X,Y)  do{ __typeof__ (X) _T = X; X = Y; Y = _T; }while(0)
 
struct test
{
  int a, b, c;
};
 
 
int main()
{
  struct test t = { 1, 2, 3 };
  struct test h = { 4, 5, 6 };
  double alfa = 0.45, omega = 9.98;
 
  struct test *pt = &t;
  struct test *th = &h;
 
  printf("%d %d %d\n", t.a, t.b, t.c );
  Swap(t, h);
  printf("%d %d %d\n", t.a, t.b, t.c );
  printf("%d %d %d\n", h.a, h.b, h.c );
 
  printf("%lf\n", alfa);
  Swap(alfa, omega);
  printf("%lf\n", alfa);
 
  printf("%d\n", pt->a);
  Swap(pt, th);
  printf("%d\n", pt->a);
}

This is tested with GCC with -std=c89 option.

[edit] C++

Generic programming in C++ is provided through templates. Templates in C++ are quite powerful: They form a Turing-complete compile-time sub-language. However, that power isn't needed for swap. Note that the C++ standard library already provides a swap function which contains optimized implementations for standard library types; thus it's advisable to use that instead of a self-written variant like the one below.

While the standard allows to separate declaration and definition of templates into different files using the export keyword, most compilers (including the most used ones) don't implement that. Therefore in practice, templates declared in header files also have to be defined there.

The implementation of the swap function template is straightforward:

template<typename T> void swap(T& left, T& right)
{
  T tmp(left);
  left = right;
  right = tmp;
}

Note that this function requires that the type T has an accessible copy constructor and assignment operator.

The standard utility 'swap' can be used to swap two values/

std::swap(x,y);;

It will work with any types.

[edit] C#

Works with: C# version 2.0+

C# 2.0 introduced the concept of generics to the language. Generics are outwardly similar to C++ templates, but are implemented quite differently: generics are maintained generically at runtime rather than being substitued with definite types by the compiler. Generics are intended to promote reusable, efficient, type-safe code, and are used widely throughout the .NET framework and 3rd party libraries, especially in collections. C# generics are less flexible than C++ templates, but are more strongly typed and arguably easier to deal with.

static void Swap<T>(ref T a, ref T b)
{
    T temp = a;
    a = b;
    b = temp;
}

[edit] Clojure

 
(defn swap [pair] (reverse pair))    ; returns a list
(defn swap [[a b]] '(b a))           ; returns a list
(defn swap [[a b]] [b a])            ; returns a vector
 

The latter two implementations use destructured binding to define local names for the two elements.

[edit] Common Lisp

(rotatef a b)
 
(psetq a b b a)

[edit] ColdFusion

This is another standard swap.

<cfset temp = a />
<cfset a = b />
<cfset b = temp />

[edit] D

The solution for D is quite similar to that for C++:

void swap(T)(ref T left, ref T right) {
  auto temp = left;
  left = right;
  right = temp;
}

The std.algorithm standard library module contains a generic swap.

[edit] dc

We use two registers to swap in POSIX dc.

1 2 sa sb la lb f
=2 1

Reverse (r) is a built-in stack command available as a GNU extension for dc.

1 2 r f
=2 1

[edit] E

(slots)

def swap(&left, &right) {
  def t := left
  left := right
  right := t
}

(functional)

def swap([left, right]) {
  return [right, left]
}

[edit] Erlang

Erlang variables are single assignment and Erlang is dynamically typed, so this task doesn't really apply.

The closest thing would be to swap the items in a list (shown in the shell).

 
1> L = [a, 2].
[a,2]
2> lists.reverse(L).
[2,a]
 

Or swap the items in a tuple (also shown in the shell).

 
1> T = {2,a}.
{2,a}
2> list_to_tuple(lists:reverse(tuple_to_list(T))).
{a,2}
 

[edit] F#

let swap (a,b) = (b,a)

[edit] Factor

Depending on how you look at it: this task doesn't apply, or it's trivial:

swap

[edit] Falcon

 
a = 1
b = 2
a,b = arr = b,a
 

Reading right to left: Assign b & a into an array variable called arr, then assign into a & b

[edit] Fortran

Works with: Fortran version 90 and later

MODULE Genericswap
  IMPLICIT NONE
 
  INTERFACE Swap
    MODULE PROCEDURE Swapint, Swapreal, Swapstring
  END INTERFACE
 
CONTAINS
 
  SUBROUTINE Swapint(a, b)
    INTEGER, INTENT(IN OUT) :: a, b
    INTEGER :: temp
    temp = a ; a = b ; b = temp
  END SUBROUTINE Swapint
 
  SUBROUTINE Swapreal(a, b)
    REAL, INTENT(IN OUT) :: a, b
    REAL :: temp
    temp = a ; a = b ; b = temp
  END SUBROUTINE Swapreal
 
  SUBROUTINE Swapstring(a, b)
    CHARACTER(*), INTENT(IN OUT) :: a, b
    CHARACTER(len(a)) :: temp
    temp = a ; a = b ; b = temp
  END SUBROUTINE Swapstring
END MODULE Genericswap
 
PROGRAM EXAMPLE
  USE Genericswap
  IMPLICIT NONE
  INTEGER :: i1 = 1, i2 = 2
  REAL :: r1 = 1.0, r2 = 2.0
  CHARACTER(3) :: s1="abc", s2="xyz"
 
  CALL Swap(i1, i2)
  CALL Swap(r1, r2)
  CALL Swap(s1, s2)
 
  WRITE(*,*) i1, i2   ! Prints 2 and 1
  WRITE(*,*) r1, r2   ! Prints 2.0 and 1.0
  WRITE(*,*) s1, s2   ! Prints xyz and abc
END PROGRAM EXAMPLE

[edit] Go

Go has support for swapping built in:

a, b = b, a

[edit] Groovy

Groovy has support for swapping built in:

(a, b) = [b, a]

But the task calls for a "generic swap method" to be written, so here it is:

def swap(a, b) {
    [b, a]
}

This function doesn't mutate anything, but simply returns a new list with the order of the elements switched. It can be used like shown below:

def (x, y) = swap(1, 3)
assert x == 3
assert y == 1

[edit] Haskell

Like everything else in Haskell, tuples are immutable. This function doesn't mutate anything, but simply returns a new pair with the order of the elements switched.

The type signature, the first line, is optional; it may be inferred.

swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)

[edit] Icon and Unicon

Icon provides :=: operator for this. Additionally, there is a reversible exchange operator <-> that reverses the exchange if resumed.

[edit] Icon

procedure main()
   local x, y, v
   v := create(1 to 2)
   every (x | y) := @v
   write(x," ",y)
   x :=: y
   write(x," ",y)
end

[edit] Unicon

This Icon solution works in Unicon.

[edit] IDL

IDL is dynamically typed and array-centric, so swapping is quite easy for any data type. The TEMPORARY function sets its argument to "undefined", and allows us to swap without any large copying.

pro swap, a, b
  c = temporary(a)
  a = temporary(b)
  b = temporary(c)
end

[edit] J

J is dynamically typed and J's cycle primitive (C.) will swap elements of an arbitrary list. See also J's reference documentation on C.

Shown here are a list of prime numbers and the result of J's parser on some random text (inverting the parsing process on the swapped result):

   (<2 4) C. 2 3 5 7 11 13 17 19
2 3 11 7 5 13 17 19
   (<0 3)&C.&.;:'Roses are red. Violets are blue.'
Violets are red. Roses are blue.

Also, if the argument list can be guaranteed to be a pair, J's reverse primitive will swap the pair.

   |.2 3
3 2
   |.&.;:'one two'
two one

[edit] Java

Works with: Java version 1.5+

class Pair<T> {
    T first;
    T second;
}
public static <T> void swap(Pair<T> p) {
   T temp = p.first;
   p.first = p.second;
   p.second = temp;
}

[edit] JavaScript

JavaScript uses references, but if a function reassigns a parametric reference, the new object only has a local reference. However, if we wrap the variables to be switched in some other structure, like an object or an array, we can easily swap the values.

There's no actual "generics", since all variables are just that, variables of some kind.

The below function expects an array of length 2 (or longer), and switches the first two values in place, in the same array. This is closely related to how the Java solution works.

function swap(arr) {
  var tmp = arr[0];
  arr[0] = arr[1];
  arr[1] = tmp;
}

[edit] Joy

Provided that the stack contains at least two elements and/or aggregates:

swap

changes the order of those elements and/or aggregates.

[edit] Lisaac

(a, b) := (b, a);

[edit] Logo

 
to swap :s1 :s2
  localmake "t thing :s1
  make :s1 thing :s2
  make :s2 :t
end
 
make "a 4
make "b "dog
swap "a "b        ; pass the names of the variables to swap
show list :a :b  ; [dog 4]
 

[edit] Lua

Lua evaluates the values on the right-hand side before assigning them to the variables on the left-hand side. This behaviour allows the following notation to be used to swap two values:

 
x, y = y, x                -- swap the values inside x and y
t[1], t[2] = t[2], t[1]    -- swap the first and second values inside table t
 

Usage example:

 
x, y = 3, 4
print(x, y)                --> 3 4
x, y = y, x                -- swap
print(x, y)                --> 4 3
 

[edit] M4

define(`def2', `define(`$1',`$2')define(`$3',`$4')')dnl
define(`swap', `def2(`$1',defn(`$2'),`$2',defn(`$1'))')dnl
dnl
define(`a',`x')dnl
define(`b',`y')dnl
a b
swap(`a',`b')
a b

Output:

x y

y x

[edit] Mathematica

Mathematica functions are generic by default; however, it has to be told not to evaluate the arguments before executing the function.

swap[a_, b_] := {a, b} = {b, a}
SetAttributes[swap, HoldAll]

[edit] MAXScript

swap a b

[edit] Metafont

In Metafont, only numeric declarations can be omitted; any other type, must be explicitly given. So our swap, in order to declare and use a proper temporary variable(? in this code), must check the type of the variable passed (we check only for a; if b is of another kind, an error will occur)

vardef swap(suffix a, b) =
  save ?; string s_;
  if boolean a: boolean ?
    elseif numeric a: numeric ? % this one could be omitted
    elseif pair a: pair ?
    elseif path a: path ?
    elseif pen a: pen ?
    elseif picture a: picture ?
    elseif string a: string ?
    elseif transform a: transform ? fi;
  ? := a; a := b; b := ?
enddef;

Examples:

j := 10;
i := 5;
show j, i;
swap(j,i);
show j, i;
 
boolean truth[];
truth1 := true;
truth2 := false;
show truth1, truth2;
swap(truth1,truth2);
show truth1, truth2;

[edit] Modula-3

GENERIC INTERFACE GenericSwap(Elem);
 
PROCEDURE Swap(VAR left: Elem.T; VAR right: Elem.T);
 
END GenericSwap.

GENERIC MODULE GenericSwap(Elem);
 
PROCEDURE Swap(VAR left: Elem.T; VAR right: Elem.T) =
  VAR temp: Elem.T := left;
  BEGIN
    left := right;
    right := temp;
  END Swap;
 
BEGIN
END GenericSwap.

Here is an example usage for integers:

INTERFACE IntSwap = GenericSwap(Integer) END IntSwap.

MODULE IntSwap = GenericSwap(Integer) END IntSwap.

MODULE Main;
 
IMPORT IntSwap, IO, Fmt;
 
VAR left := 10;
    right := 20;
 
BEGIN
  IO.Put("Left = " & Fmt.Int(left) & "\n");
  IntSwap.Swap(left, right);
  IO.Put("Left = " & Fmt.Int(left) & "\n");
END Main.

Output:

Left = 10
Left = 20

[edit] Nial

Like J

|reverse 1 2
=2 1

[edit] OCaml

Tuples are immutable in OCaml. This function doesn't mutate anything, but simply returns a new pair with the order of the elements switched.

let swap (x, y) = (y, x)

If the arguments are constrained to be reference values, a swap function is simple:

let swapref x y =
  let temp = !x in
    x := !y;
    y := temp

[edit] Octave

GNU Octave has no way to pass a value by reference to a function; so to define a swap we must do as follow:

function [a, b] = swap(ia, ib)
  a = ib; b = ia;
endfunction
 
% testing
va = 2; vb = 5;
printf("%d %d\n", va, vb);
[va, vb] = swap(va, vb);
printf("%d %d\n", va, vb);

[edit] Oz

Oz variables are dataflow variables and cannot be changed once a value has been assigned. So a swap operation on dataflow variables does not make sense.

We can write a swap procedure for cells, though. Cells are mutable references.

  proc {SwapCells A B}
     Tmp = @A
  in
     A := @B
     B := Tmp
  end

Or shorter, if we exploit the fact that the assignment operator := returns the old value of the cells:

  proc {SwapCells A B}
     B := A := @B
  end

A functional swap, operating on pairs:

  fun {SwapPair A#B}
     B#A
  end

[edit] Perl

Perl has support for swapping built-in

($y, $x) = ($x, $y);

Here's a generic swap routine:

sub swap {@_[0, 1] = @_[1, 0]}

[edit] Perl 6

As Perl 5. Perl 6 supports type constraints for variables and subroutines, unlike Perl 5, but the default is still to permit all values.

[edit] PHP

function swap(&$a, &$b) {
    list($a, $b) = array($b, $a);
}

[edit] PicoLisp

xchg works with any data type

(let (A 1  B 2)
   (xchg 'A 'B)
   (println A B) )
 
(let (Lst1 '(a b c)  Lst2 '(d e f))
   (xchg (cdr Lst1) (cdr Lst2))
   (println Lst1 Lst2) )

Output:

2 1
(a e c) (d b f)

[edit] PL/I

 
/* FIRST WAY, USING THE PREPROCESSOR: */   /* 16 August 2010 */
 
%swap: procedure (a, b);
   declare (a, b) character;
   return ( 't=' || a || ';' || a || '=' || b || ';' || b '=t;' );
%end swap;
%activate swap;
 
The statement:-
   swap (p, q);
 
is replaced, at compile time, by the three statements:
   t = p; p = q; q = t;
 
/* SECOND WAY USING GENERIC PROCEDURES: */
 
declare swap generic (
   swapf when (float, float),
   swapc when (char, char));
 
swapf: proc (a, b);
   declare (a, b, t) float;
   t = a; a = b; b = t;
end swapf;
swapc: proc (a, b);
   declare (a, b) character(*);
   declare t character (length(b));
   t = a; a = b; b = t;
end swapc;
 
declare (r, s) character (5);
call swap (r, s);
 

[edit] Pop11

Swap is easily done via multiple assignment:

(a, b) -> (b, a);

Pop11 is dynamically typed, so the code above is "generic".

[edit] PowerShell

PowerShell allows swapping directly, through tuple assignment:

$b, $a = $a, $b

But one can also define a function which swaps the values of two references:

function swap ([ref] $a, [ref] $b) {
    $a.Value, $b.Value = $b.Value, $a.Value
}

When using this function the arguments have to be explicitly given as references:

swap ([ref] $a) ([ref] $b)

[edit] Prolog

 
swap(A,B,B,A).
 
?- swap(1,2,X,Y).
X = 2,
Y = 1.
 

[edit] PureBasic

Built in function:

Swap a, b

[edit] Python

Python has support for swapping built in:

a, b = b, a

But the task calls for a "generic swap method" to be written, so here it is:

def swap(a, b):
    return b, a

Note that tuples are immutable in Python. This function doesn't mutate anything, but simply returns a new pair with the order of the elements switched.

[edit] REBOL

rebol [
	Title: "Generic Swap"
	Author: oofoe
	Date: 2009-12-06
	URL: http://rosettacode.org/wiki/Generic_swap
	Reference: [http://reboltutorial.com/blog/rebol-words/]
]
 
swap: func [
	"Swap contents of variables."
	a [word!] b [word!] /local x
][
	x: get a  
	set a get b  
	set b x
]
 
answer: 42  ship: "Heart of Gold"
swap 'answer 'ship ; Note quoted variables.
print rejoin ["The answer is " answer ", the ship is " ship "."]

Output:

The answer is Heart of Gold, the ship is 42.

[edit] Ruby

Ruby has support for swapping built in:

a, b = b, a

But the task calls for a "generic swap method" to be written, so here it is:

def swap(a, b)
    return b, a
end

This function doesn't mutate anything, but simply returns a new array with the order of the elements switched.

[edit] Sather

A possible way that needs the type of the objects to be specified:

class SWAP{T} is
  swap(inout a, inout b:T) is
    t ::= a;
    a := b;
    b := t;
  end;
end;

class MAIN is
  main is
    x ::= 10;
    y ::= 20;
    SWAP{INT}::swap(inout x, inout y);
    #OUT + x + ", " + y + "\n";
  end;
end;

[edit] Scala

Scala has type parameters and abstract types (not to be confused with abstract data types). The swap example is about as simple as such things can be, with no variance or high-order type parameters.

The return type needed not be declared in the example below. It is shown for clarity. However, as Scala does not pass parameters by reference, it cannot swap values in-place. To make up for that, it is receiving two values, and returning a tuple with the values inverted.

def swap[A,B](a: A, b: B): (B, A) = (b, a)

[edit] Scheme

This must be done with macros, since the parameters inside a procedure are copies of the actual parameters.

(define-syntax swap!
  (syntax-rules ()
    ((_ a b)
     (let ((tmp a))
       (set! a b)
       (set! b tmp)))))

[edit] Seed7

A generic template to generate swap functions is defined with:

const proc: generate_swap (in type: aType) is func
  begin
 
    const proc: swap (inout aType: left, inout aType: right) is func
      local
        var aType: temp is aType.value;
      begin
        temp := left;
        left := right;
        right := temp;
      end func;
 
  end func;

An instance of a swap function can be generated with:

generate_swap(integer);
generate_swap(string);

A swap function can be called with:

swap(a, b);

[edit] Slate

This must be done with a macro method in Slate, but is in the standard library:

x@(Syntax LoadVariable traits) swapWith: y@(Syntax LoadVariable traits) &environment: env
"A macro that expands into simple code swapping the values of two variables
in the current scope."
[| tmpVar |
  env ifNil: [error: 'Cannot swap variables outside of a method'].
  tmpVar: env addVariable.
  {tmpVar store: x variable load.
   x variable store: y variable load.
   y variable store: tmpVar load} parenthesize
].

Usage:

a `swapWith: b

[edit] Smalltalk

Works with: GNU Smalltalk

An OrderedCollection can collect any kind of objects; so this swap implementend extending the OrderedCollection class is really generic.

OrderedCollection extend [
    swap: a and: b [
	|t|
	t := self at: a.
	self at: a put: (self at: b).
	self at: b put: t
    ]
]

[edit] SNOBOL4

The "canonical" version from M. Emmers tutorial:

* SWAP(.V1, .V2) - Exchange the contents of two variables.
*  The variables must be prefixed with the name operator
*  when the function is called.
 
        DEFINE('SWAP(X,Y)TEMP')              :(SWAP_END)
SWAP    TEMP = $X
        $X = $Y
        $Y = TEMP                            :(RETURN)
SWAP_END

[edit] Standard ML

Tuples are immutable in Standard ML. This function doesn't mutate anything, but simply returns a new pair with the order of the elements switched.

fun swap (x, y) = (y, x)

If the arguments are constrained to be reference values, a swap function is simple:

fun swapref (x, y) =
    let temp = !x in x := !y; y := temp end

[edit] Tcl

Works with: Tcl version 8.5

proc swap {aName bName} {
    upvar 1 $aName a $bName b
    lassign [list $a $b] b a
}

Works with: Tcl version 8.4

proc swap {aName bName} {
    upvar 1 $aName a $bName b
    foreach {b a} [list $a $b] break
}

set a 1
set b 2
puts "before\ta=$a\tb=$b"
swap a b
puts "after\ta=$a\tb=$b"

Outputs:

before	a=1	b=2
after	a=2	b=1

[edit] ThinBASIC

Generic function, swap the content of two variables.

Swap Var1, Var2

[edit] TI-89 BASIC

TI-89 BASIC is dynamically typed, so the genericity is implicit. It has no pass by reference, so we must pass the variable names as strings. It is dynamically scoped, so we must choose hopefully distinct names for the variables.

Define swap(swapvar1, swapvar2) = Prgm
  Local swaptmp
  #swapvar1 → swaptmp
  #swapvar2 → #swapvar1
  swaptmp → #swapvar2
EndPrgm
 
1 → x
2 → y
swap("x", "y")
x
    2
y
    1

[edit] Trith

As with other stack-based languages (e.g. Factor and Joy), the solution to this task is a trivial matter of swapping the top two operands on the stack:

swap

[edit] Ursala

Most functions are polymorphic without any special provision to that effect. Swapping a pair is a very inexpensive operation because no actual copying or overwriting is performed.

pmgs("x","y") = ("y","x")    # the pattern matching way
 
ugs = ~&rlX                  # the idiosyncratic Ursala way
 
#cast %sWL
 
test = <pmgs ('a','b'),ugs ('x','y')>

output:

<('b','a'),('y','x')>

[edit] V

Using the view to shuffle the stack.

[swap [a b : b a] view].
 
1 2 swap
= 2 1
'hello' 'hi' swap

='hi' 'hello'

[edit] VBScript

This works for everything: strings, dates, booleans ... The fact is, with everything being a Variant, it's always generic.

sub swap( byref x, byref y )
	dim temp
	temp = x
	x = y
	y = temp
end sub

Usage:

dim a 
a = "woof"
dim b
b = now()
swap a,b
wscript.echo a
wscript.echo b

Output:

5/02/2010 2:35:36 PM
woof

[edit] Visual Basic

Visual Basic can use the VBScript example above, with the caveat that it won't work if any DEFtype (except DefVar) has been used. (The default data type is Variant, which can be used as a stand-in for any variable type.)

Also, the sub will fail if one arg is a string containing non-numeric data and the other arg is numeric.