String append
You are encouraged to solve this task according to the task description, using any language you may know.
Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.
You may see other such operations in the Basic Data Operations category, or:
Integer Operations
Arithmetic |
Comparison
Boolean Operations
Bitwise |
Logical
String Operations
Concatenation |
Interpolation |
Comparison |
Matching
Memory Operations
Pointers & references |
Addresses
Most languages provide a way to concatenate two string values, but some languages also provide a convenient way to append in-place to an existing string variable without referring to the variable twice.
- Task
Create a string variable equal to any text value.
Append the string variable with another string literal in the most idiomatic way, without double reference if your language supports it.
Show the contents of the variable after the append operation.
Ada
<lang ada> with Ada.Strings.Unbounded; use Ada.Strings.Unbounded; with Ada.Text_IO.Unbounded_Io; use Ada.Text_IO.Unbounded_IO;
procedure String_Append is
Str : Unbounded_String := To_Unbounded_String("Hello");
begin
Append(Str, ", world!"); Put_Line(Str);
end String_Append; </lang>
- Output:
Hello, world!
ALGOL 68
File: String_append.a68<lang algol68>#!/usr/bin/a68g --script #
- -*- coding: utf-8 -*- #
STRING str := "12345678"; str +:= "9!"; print(str)</lang>
- Output:
123456789!
ARM Assembly
<lang ARM Assembly> /* ARM assembly Raspberry PI */ /* program appendstr.s */
/* Constantes */ .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ WRITE, 4 @ Linux syscall
.equ BUFFERSIZE, 100
/* Initialized data */ .data szMessString: .asciz "String :\n" szString1: .asciz "Alphabet : " sComplement: .fill BUFFERSIZE,1,0 szString2: .asciz "abcdefghijklmnopqrstuvwxyz"
szCarriageReturn: .asciz "\n"
/* UnInitialized data */ .bss
/* code section */ .text .global main main:
ldr r0,iAdrszMessString @ display message bl affichageMess ldr r0,iAdrszString1 @ display begin string bl affichageMess ldr r0,iAdrszCarriageReturn @ display line return bl affichageMess ldr r0,iAdrszString1 ldr r1,iAdrszString2 bl append @ append sting2 to string1 ldr r0,iAdrszMessString bl affichageMess ldr r0,iAdrszString1 @ display string bl affichageMess ldr r0,iAdrszCarriageReturn bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code mov r7, #EXIT @ request to exit program svc 0 @ perform system call
iAdrszMessString: .int szMessString iAdrszString1: .int szString1 iAdrszString2: .int szString2 iAdrszCarriageReturn: .int szCarriageReturn /******************************************************************/ /* append two strings */ /******************************************************************/ /* r0 contains the address of the string1 */ /* r1 contains the address of the string2 */ append:
push {r0,r1,r2,r7,lr} @ save registers mov r2,#0 @ counter byte string 1
1:
ldrb r3,[r0,r2] @ load byte string 1 cmp r3,#0 @ zero final ? addne r2,#1 bne 1b @ no -> loop mov r4,#0 @ counter byte string 2
2:
ldrb r3,[r1,r4] @ load byte string 2 strb r3,[r0,r2] @ store byte string 1 cmp r3,#0 @ zero final ? addne r2,#1 @ no -> increment counter 1 addne r4,#1 @ no -> increment counter 2 bne 2b @ no -> loop
100:
pop {r0,r1,r2,r7,lr} @ restaur registers bx lr @ return
/******************************************************************/ /* display text with size calculation */ /******************************************************************/ /* r0 contains the address of the message */ affichageMess:
push {r0,r1,r2,r7,lr} @ save registers mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index cmp r1,#0 @ if 0 its over addne r2,r2,#1 @ else add 1 in the length bne 1b @ and loop @ so here r2 contains the length of the message mov r1,r0 @ address message in r1 mov r0,#STDOUT @ code to write to the standard output Linux mov r7, #WRITE @ code call system "write" svc #0 @ call system pop {r0,r1,r2,r7,lr} @ restaur registers bx lr @ return
</lang>
AutoHotkey
<lang autohotkey>s := "Hello, " s .= "world." MsgBox % s</lang>
- Output:
Hello, world.
AWK
<lang AWK>
- syntax: GAWK -f STRING_APPEND.AWK
BEGIN {
s = "foo" s = s "bar" print(s) exit(0)
} </lang>
- Output:
foobar
Axe
<lang axe>Lbl STRCAT Copy(r₂,r₁+length(r₁),length(r₂)+1) r₁ Return</lang>
BASIC
Applesoft BASIC
<lang BASIC>S$ = "Hello" S$ = S$ + " World!" PRINT S$</lang>
BBC BASIC
<lang BBC BASIC> S$="Hello"
S$+=" World!" PRINT S$ END</lang>
- Output:
Hello World!
IS-BASIC
<lang IS-BASIC>100 LET S$="Hello" 110 LET S$=S$&" World!" 120 PRINT S$</lang>
Bracmat
<lang Bracmat>str="Hello"; str$(!str " World!"):?str; out$!str;</lang>
- Output:
Hello World!
C
<lang c>#include<stdio.h>
- include<string.h>
int main() {
char str[24]="Good Morning"; char *cstr=" to all"; char *cstr2=" !!!"; int x=0; //failure when space allocated to str is insufficient.
if(sizeof(str)>strlen(str)+strlen(cstr)+strlen(cstr2)) { /* 1st method*/ strcat(str,cstr);
/*2nd method*/ x=strlen(str); sprintf(&str[x],"%s",cstr2);
printf("%s\n",str);
} return 0;
}</lang>
- Output:
Good Morning to all !!!
C++
<lang cpp>#include <iostream>
- include <string>
int main( ) {
std::string greeting( "Hello" ) ; greeting.append( " , world!" ) ; std::cout << greeting << std::endl ; return 0 ;
}</lang>
- Output:
Hello , world!
C#
<lang csharp>class Program {
static void Main(string[] args) { string x = "foo"; x += "bar"; System.Console.WriteLine(x); }
}</lang>
Clojure
Using global vars. <lang clojure>user=> (def s "app")
- 'user/s
user=> s "app" user=> (def s (str s "end"))
- 'user/s
user=> s "append"</lang>
Using local bindings. <lang clojure> user=> (let [s "ap", s (str s "pend")] s) "append"</lang>
COBOL
COBOL is not really a variable length field programming language. Most data items are fixed in size at compile time.
This example uses OCCURS DEPENDING ON, and reference modification to simulate a string append, all within an already maximally bounded character field. This type of programming task, while possible, is not overly common in COBOL applications.
<lang COBOL> identification division.
program-id. string-append.
data division. working-storage section. 01 some-string. 05 elements pic x occurs 0 to 80 times depending on limiter. 01 limiter usage index value 7. 01 current usage index.
procedure division. append-main.
move "Hello, " to some-string
*> extend the limit and move using reference modification set current to length of some-string set limiter up by 5 move "world" to some-string(current + 1:) display some-string
goback. end program string-append.
</lang>
- Output:
$ cobc -xj string-append.cob Hello, world
CoffeeScript
<lang coffeescript>a = "Hello, " b = "World!" c = a + b
console.log c</lang> Or with concat: <lang coffeescript>console.log "Hello, ".concat "World!"</lang>
- Output:
Hello, World!
Common Lisp
Similar to the Racket solution, a macro is necessary to append in-place: <lang lisp>(defmacro concatenatef (s &rest strs)
"Append additional strings to the first string in-place." `(setf ,s (concatenate 'string ,s ,@strs)))
(defvar *str* "foo") (concatenatef *str* "bar") (format T "~a~%" *str*) (concatenatef *str* "baz" "abc" "def") (format T "~a~%" *str*)</lang>
Output:
foobar foobarbazabcdef
D
<lang d>import std.stdio;
void main() {
string s = "Hello"; s ~= " world!"; writeln(s);
}</lang>
- Output:
Hello world!
Dyalect
<lang Dyalect>var s = "foo" s += "bar" print(s)</lang>
EasyLang
<lang>a$ = "hello" a$ &= " world" print a$</lang>
EchoLisp
<lang lisp>
- Solution from Common Lisp and Racket
(define-syntax-rule (set-append! str tail)
(set! str (string-append str tail)))
(define name "Albert") → name
(set-append! name " de Jeumont-Schneidre") name
→ "Albert de Jeumont-Schneidre"
</lang>
Elena
ELENA 4.x : <lang elena>import extensions; import extensions'text;
public program() {
var s := StringWriter.load("Hello"); s.append:" World"; console.printLine:s.readChar()
}</lang>
Elixir
<lang elixir>iex(60)> s = "Hello" "Hello" iex(61)> s <> " World!" "Hello World!"</lang>
Emacs Lisp
version 1
<lang Emacs Lisp> (defun glue (str1 str2)
(concat str1 str2) )
</lang>
version 2
<lang Emacs Lisp> (defun glue (str1 str2)
(format "%s%s" str1 str2) )
</lang> Eval: <lang Emacs Lisp> (setq str "Hello, ") (setq str (glue str "World!") ) (insert str) </lang> Output:
Hello, World!
Erlang
- Output:
1> S = "Hello". "Hello" 2> S ++ " world". "Hello world"
Euphoria
<lang euphoria> sequence string = "String"
printf(1,"%s\n",{string})
string &= " is now longer\n"
printf(1,"%s",{string}) </lang>
- Output:
String String is now longer
F#
Strings are immutable in .NET. To append (to the same variable) the variable has to be declared mutable. <lang fsharp>let mutable x = "foo" x <- x + "bar" printfn "%s" x</lang>
Factor
<lang factor>"Hello, " "world!" append</lang>
- Output:
"Hello, world!"
Falcon
<lang falcon> /* Added by Aykayayciti Earl Lamont Montgomery April 10th, 2018 */
s1, s2 = "Hello", "Foo" > s1 + " World" printl(s2 + " bar") </lang>
- Output:
Hello World Foo bar [Finished in 0.2s]
Forth
<lang Forth>\ Strings in Forth are simply named memory locations
create astring 256 allot \ create a "string"
s" Hello " astring PLACE \ initialize the string
s" World!" astring +PLACE \ append with "+place"</lang>
Test at the console
<lang> ok s" Hello " astring place ok s" World!" astring +place ok astring count type Hello World! ok </lang>
Fortran
Using deferred length character strings:
<lang Fortran> program main
character(len=:),allocatable :: str
str = 'hello' str = str//' world'
write(*,*) str
end program main </lang>
FreeBASIC
<lang freebasic>' FB 1.05.0 Win64
Var s = "String" s += " append" Print s Sleep</lang>
- Output:
String append
Gambas
Click this link to run this code <lang gambas>Public Sub Main() Dim sString As String = "Hello "
sString &= "World!" Print sString
End</lang> Output:
Hello World!
Genie
<lang genie>[indent=4] /* String append, in Genie */ init
str:string = "Hello" str += ", world"
print str</lang>
- Output:
prompt$ valac stringAppend.gs prompt$ ./stringAppend Hello, world
GlovePIE
<lang glovepie>var.string="This is " var.string+="Sparta!" debug=var.string</lang>
Go
<lang go>s := "foo" s += "bar"</lang>
String Builder
The first solution redefines the string variable every time. It might be short in code but it uses much CPU cycles. A better way is to use `string.Builder` but it is not a string. It is more like a buffer which can produce a string. And it really appends the string to the existing variable. <lang go> package main
import (
"fmt" "strings"
)
func main() {
var s strings.Builder s.WriteString("foo") s.WriteString("bar") fmt.Print(s.String())
} </lang>
- Output:
foobar
Gosu
<lang gosu>// Example 1 var s = "a" s += "b" s += "c" print(s)
// Example 2 print("a" + "b" + "c")
// Example 3 var a = "a" var b = "b" var c = "c" print("${a}${b}${c}")</lang>
- Output:
abc abc abc
Groovy
<lang Groovy> class Append{ static void main(String[] args){ def c="Hello "; def d="world"; def e=c+d; println(e); } } </lang>
- Output:
Hello world
Haskell
<lang haskell> main = putStrLn ("Hello" ++ "World") </lang>
Icon and Unicon
In both languages you can:
<lang unicon> procedure main()
s := "foo" s ||:= "bar" write(s)
end </lang>
Outputs:
->ss foobar ->
J
<lang j> s=: 'new'
s
new
s=: s,' value' NB. append is in-place s
new value</lang>
Java
<lang Java>String sa = "Hello"; sa += ", World!"; System.out.println(sa);
StringBuilder ba = new StringBuilder(); ba.append("Hello"); ba.append(", World!"); System.out.println(ba.toString());</lang>
- Output:
Hello, World! Hello, World!
JavaScript
<lang JavaScript>var s1 = "Hello"; s1 += ", World!"; print(s1);
var s2 = "Goodbye"; // concat() returns the strings together, but doesn't edit existing string // concat can also have multiple parameters print(s2.concat(", World!"));</lang>
- Output:
"Hello, World!" "Goodbye, World!"
jq
jq's +
operator can be used to append two strings, and under certain circumstances the +=
operator can be used as an abbreviation for appending a string to an existing string. For example, all three of the following produce the same output:<lang jq>"Hello" | . += ", world!"
["Hello"] | .[0] += ", world!" | .[0]
{ "greeting": "Hello"} | .greeting += ", world!" | .greeting</lang>
However the +=
operator cannot be used with jq variables in the conventional manner. One could nevertheless use the technique illustrated by the following:<lang jq>"Hello" as $a | $a | . += ", world!" as $a | $a</lang>
Jsish
From Javascript entry. <lang javascript>/* String append, in Jsish */ var str = 'Hello';
- str += ', world';
var s2 = 'Goodbye';
- s2.concat(', World!');
/*
!EXPECTSTART!
str += ', world' ==> Hello, world s2.concat(', World!') ==> Goodbye, World!
!EXPECTEND!
- /</lang>
- Output:
prompt$ jsish --U stringAppend.jsi str += ', world' ==> Hello, world s2.concat(', World!') ==> Goodbye, World!
Julia
<lang julia>s = "Hello" s *= ", world!"</lang>
- Output:
"Hello, world!"
Kotlin
<lang kotlin>fun main(args: Array<String>) {
var s = "a" s += "b" s += "c" println(s) println("a" + "b" + "c") val a = "a" val b = "b" val c = "c" println("$a$b$c")
}</lang>
- Output:
abc abc abc
Lasso
<lang Lasso>local(x = 'Hello')
- x->append(', World!')
- x</lang>
- Output:
Hello, World!
Lingo
<lang lingo>str = "Hello" put " world!" after str put str -- "Hello world!"</lang>
LiveCode
Livecode has an "after" keyword for this <lang LiveCode>local str="live" put "code" after str</lang> Output is "livecode"
Lua
Not possible as strings are immutable. We can demonstrate their immutability using 'self': <lang Lua>function string:show ()
print(self)
end
function string:append (s)
self = self .. s
end
x = "Hi " x:show() x:append("there!") x:show()</lang>
- Output:
Hi Hi
You can of course concatentate them and store the result in the original variable name but that requires a double reference: <lang Lua>x = "Hi " x = x .. "there!" print(x)</lang>
- Output:
Hi there!
M2000 Interpreter
Documents in M2000 are objects with paragraphs.
<lang M2000 Interpreter> a$="ok" a$+="(one)" Print a$
Document b$ b$="ok" b$="(one)" Print b$ </lang>
- Output:
ok(one) ok(one)
Maple
<lang maple>a := "Hello"; b := cat(a, " World"); c := `||`(a, " World");</lang>
- Output:
"Hello" "Hello World" "Hello World"
Mathematica
<lang Mathematica> (* mutable strings are not supported *) s1 = "testing"; s1 = s1 <> " 123"; s1</lang>
- Output:
"testing 123"
MontiLang
<lang MontiLang>|Hello | |world!| swap + print</lang> <lang MontiLang>|Hello | var hello . |world!| var world . world hello + print</lang>
Neko
The plus operator +, concats strings.
<lang ActionScript>/**
<doc>
String append in Neko</doc>
- /
var str = "Hello" str += ", world" $print(str, "\n")</lang>
- Output:
prompt$ nekoc string-append.neko prompt$ neko ./string-append.n Hello, world
NetRexx
<lang NetRexx>s_ = 'Hello' s_ = s_', world!' say s_</lang>
- Output:
Hello, world!
NewLISP
<lang NewLISP>(setq str "foo")
(push "bar" str -1)
- or as an alternative introduced in v.10.1
(extend str "bar")
(println str) </lang>
Nim
<lang nim>var str = "123456" str.add("78") # two ways str &= "9!" # to append</lang>
Objeck
<lang objeck> class Append {
function : Main(args : String[]) ~ Nil { x := "foo"; x->Append("bar"); x->PrintLine(); }
} </lang>
OCaml
<lang ocaml>let () =
let s = Buffer.create 17 in Buffer.add_string s "Bonjour"; Buffer.add_string s " tout le monde!"; print_endline (Buffer.contents s)</lang>
- Output:
Bonjour tout le monde!
Oforth
<lang Oforth>StringBuffer new "Hello, " << "World!" << println</lang>
PARI/GP
Not supported in GP. <lang parigp>s = "Hello"; s = Str(s, ", world!")</lang>
- Output:
%1 = "Hello, world!"
Pascal
<lang Pascal>program StringAppend; {$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads} cthreads, {$ENDIF}{$ENDIF} Classes { you can add units after this };
var
s: String = 'Hello';
begin
s += ' World !'; WriteLn(S); ReadLn;
end.</lang> Output:
Hello World !
Perl
<lang perl>my $str = 'Foo'; $str .= 'bar'; print $str;</lang>
- Output:
Foobar
Perl 6
<lang perl6>my $str = "foo"; $str ~= "bar"; say $str;</lang>
- Output:
foobar
Phix
<lang Phix>string s = "this string" ?s s &= " is now longer" ?s</lang>
- Output:
"this string" "this string is now longer"
PicoLisp
<lang picolisp>(setq Str1 "12345678") (setq Str1 (pack Str1 "9!")) (println Str1)</lang>
- Output:
"123456789!"
PL/I
<lang PL/I>Cat: procedure options (main);
declare s character (100) varying; s = 'dust '; s ||= 'bowl'; put (s);
end Cat;</lang>
dust bowl
Plain TeX
Works with any TeX engine <lang tex>\def\addtomacro#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}} \def\foo{Hello} Initial: \foo
\addtomacro\foo{ world!} Appended: \foo \bye</lang>
pdf or dvi output:
Initial: Hello Appended: Hello world!
PowerShell
<lang PowerShell> $str = "Hello, " $str += "World!" $str </lang>
Hello, World!
PureBasic
<lang purebasic>S$ = "Hello" S$ = S$ + " Wo" ;by referencing the string twice S$ + "rld!" ;by referencing the string once If OpenConsole()
PrintN(S$)
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input() CloseConsole()
EndIf</lang> Sample output:
Hello World!
Python
File: String_append.py<lang python>#!/usr/bin/env python
- -*- coding: utf-8 -*- #
str = "12345678"; str += "9!"; print(str)</lang>
- Output:
123456789!
Racket
<lang racket>;there is no built-in way to set! append in racket (define mystr "foo") (set! mystr (string-append mystr " bar")) (displayln mystr)
- but you can create a quick macro to solve that problem
(define-syntax-rule (set-append! str value)
(set! str (string-append str value)))
(define mymacrostr "foo") (set-append! mymacrostr " bar") (displayln mystr)</lang>
- Output:
foo bar foo bar
REXX
using abutment
<lang rexx>s='he' s=s'llo world!' Say s</lang> output
hello world!
using concatenation
<lang rexx>s="He" s=s || 'llo, World!' /*same as: s=s||'llo, World!' */ say s</lang> output
Hello, World!
Ring
<lang ring> aString1 = "Welcome to the " aString2 = "Ring Programming Language" aString3 = aString1 + aString2 see aString3 </lang>
Robotic
<lang robotic> set "$str1" to "Hello " inc "$str1" by "world!"
- "&$str1&"
end </lang>
Ruby
<lang ruby>s = "Hello wo" s += "rld" # new string object s << "!" # mutates in place, same object puts s</lang>
- Output:
Hello world!
Rust
<lang rust> use std::ops::Add;
fn main(){
let hello = String::from("Hello world"); println!("{}", hello.add("!!!!"));
}</lang>
- Output:
Hello world!!!!
Real append
The first solution doesn't append to the string variable. This solution really appends to the existing variable. <lang rust> fn main(){
let mut hello = String::from("Hello world"); hello.push_str("!!!!"); println!("{}", hello);
} </lang>
- Output:
Hello world!!!!
Scala
An evaluation in Scala worksheet. <lang scala> var d = "Hello" // Mutables are discouraged //> d : String = Hello
d += ", World!" // var contains a totally new re-instantiationed String
val s = "Hello" // Immutables are recommended //> s : String = Hello val s1 = s + s //> s1 : String = HelloHello val f2 = () => " !" //Function assigned to variable //> f2 : () => String = <function0> println(s1 + f2()); //> HelloHello !</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var string: str is "12345678"; begin str &:= "9!"; writeln(str); end func;</lang>
- Output:
123456789!
Sidef
<lang ruby>var str = 'Foo'; str += 'bar'; say str;</lang>
- Output:
Foobar
SNOBOL4
<lang SNOBOL4> s = "Hello"
s = s ", World!" OUTPUT = s
END</lang>
- Output:
Hello, World!
Stata
<lang stata>sca s="Ars Longa" sca s=s+" Vita Brevis" di s
Ars Longa Vita Brevis</lang>
Swift
<lang swift>var s = "foo" // "foo" s += "bar" // "foobar" print(s) // "foobar" s.appendContentsOf("baz") // "foobarbaz" print(s) // "foobarbaz"</lang>
Tcl
String concatenation is a fundamental feature of the Tcl language, and there is also an append
that makes concatenation even simpler:
<lang tcl>set s "he"
set s "${s}llo wo"; # The braces distinguish varname from text to concatenate
append s "rld"
puts $s</lang>
- Output:
hello world
Ursa
<lang ursa>decl string str set str "hello "
- append "world" to str
set str (+ str "world")
- outputs "hello world"
out str endl console</lang>
Vala
<lang vala>void main() {
string x = "foo"; x += "bar\n"; print(x);
}</lang>
VBA
<lang VB>Function StringAppend() Dim s As String s = "foo" s = s & "bar" Debug.Print s End Function</lang>
VBScript
<lang vb>s = "Rosetta" s = s & " Code" WScript.StdOut.Write s</lang>
- Output:
Rosetta Code
Wart
<lang python>s <- "12345678" s <- (s + "9!")</lang>
zkl
zkl strings are immutable, but byte blobs are mutable. <lang zkl>var s="foo"; s.append("bar"); //-->new string "foobar", var s unchanged s+="bar"; //-->new string "foobar", var s modifed to new value
s=Data(Void,"foo"); // byte blob/character blob/text editor buffer s.append("bar"); // or s+="bar" s.text; //-->"foobar"</lang>
- Programming Tasks
- Basic language learning
- String manipulation
- Basic Data Operations
- Simple
- Ada
- ALGOL 68
- ARM Assembly
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- BBC BASIC
- IS-BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- COBOL
- CoffeeScript
- Common Lisp
- D
- Dyalect
- EasyLang
- EchoLisp
- Elena
- Elixir
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- Falcon
- Forth
- Fortran
- FreeBASIC
- Gambas
- Genie
- GlovePIE
- Go
- Gosu
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- Kotlin
- Lasso
- Lingo
- LiveCode
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- MontiLang
- Neko
- NetRexx
- NewLISP
- Nim
- Objeck
- OCaml
- Oforth
- PARI/GP
- Pascal
- Perl
- Perl 6
- Phix
- PicoLisp
- PL/I
- PlainTeX
- PowerShell
- PureBasic
- Python
- Racket
- REXX
- Ring
- Robotic
- Ruby
- Rust
- Scala
- Seed7
- Sidef
- SNOBOL4
- Stata
- Swift
- Tcl
- Ursa
- Vala
- VBA
- VBScript
- Wart
- Zkl
- Bc/Omit
- Dc/Omit