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

```fsharp
open System

[<EntryPoint>]
let main args =
    let s = "hello"
    Console.Write(s)
    Console.WriteLine(" literal")
    let s2 = s + " literal"
    Console.WriteLine(s2)
    0

Factor

"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print

Falcon

'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic''

/* created by Aykayayciti Earl Lamont Montgomery
April 9th, 2018 */

s = "critical"
> s + " literal"
s2 = s + " literal"
> s2

{{out}}

critical literal
critical literal
[Finished in 0.2s]

Fantom

Illustrating in fansh:

 a := "abc"
abc
fansh> b := a + "def"
abcdef
fansh> a
abc
fansh> b
abcdef

Forth

{{works with|GNU Forth}}

s" hello" pad place
pad count type
s"  there!" pad +place    \ +place is called "append" on some Forths
pad count type

Fortran

program StringConcatenation

integer, parameter          :: maxstringlength = 64
character (maxstringlength) :: s1, s = "hello"

print *,s // " literal"
s1 = trim(s) // " literal"
print *,s1

end program

FreeBASIC

' FB 1.05.0 Win64

Var s1 = "String"
Var s2 = s1 + " concatenation"
Print s1
Print s2
Sleep

{{out}}

String
String concatenation

Frink

a = "Frink"
b = a + " rules!"
println[b]

Gambas

In gambas, the ampersand symbol is used as a concatenation operator:

'''[https://gambas-playground.proko.eu/?gist=098450adbbe0e284f0b9cdac67d74dda Click this link to run this code]'''

Public sub main()
DIM bestclub AS String
DIM myconcat AS String

bestclub = "Liverpool"
myconcat = bestclub & " Football Club"

Print myconcat

End

GlovePIE

var.text1="Hello, "
debug=var.text1+"world!"

Go

package main

import "fmt"

func main() {
    // text assigned to a string variable
    s := "hello"

    // output string variable
    fmt.Println(s)

    // this output requested by original task descrption, although
    // not really required by current wording of task description.
    fmt.Println(s + " literal")

    // concatenate variable and literal, assign result to another string variable
    s2 := s + " literal"

    // output second string variable
    fmt.Println(s2)
}

{{out}}

hello
hello literal
hello literal

Golfscript

"Greetings ":s;
s"Earthlings"+puts
s"Earthlings"+:s1;
s1 puts

Groovy

def s = "Greetings "
println s + "Earthlings"

def s1 = s + "Earthlings"
println s1

{{out}}

Greetings Earthlings
Greetings Earthlings

Halon

The dot (concatenation) operator may cast datatypes to strings.

echo "Hello" . "World " . 123;

Haskell

import System.IO
s = "hello"
s1 = s ++ " literal"
main = do putStrLn (s ++ " literal")
          putStrLn s1

HicEst

CHARACTER s = "hello", sl*100

WRITE() s // " literal"
sl = s // " literal"
WRITE() sl

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

procedure main()
s1 := "hello"
write(s2 := s1 || " there.")  # capture the reuslt for
write(s2)                     # ... the 2nd write
end

IDL

s1='Hello'
print, s1 + ' literal'
s2=s1 + ' literal'
print, s2

J

   s1 =. 'Some '
   ]s1, 'text '
Some text
   ]s2 =. s1 , 'more text!'
Some more text!

For more info see:

• http://www.jsoftware.com/help/dictionary/d320.htm on ,
• http://www.jsoftware.com/help/dictionary/d500.htm on ]

Java

public class Str{
   public static void main(String[] args){
      String s = "hello";
      System.out.println(s + " literal");
      String s2 = s + " literal";
      System.out.println(s2);
   }
}

{{out}}

hello literal
hello literal

JavaScript

var s = "hello"
print(s + " there!")

jq

"hello" as $s | $s + " there!"

{{Out}}

Use the -r command-line option if you wish

to suppress the string quotation marks

hello there!

Julia

s = "hello"
println(s * " there!")

K

Translation of J code:

s1: "Some "
s1, "text "
s2: s1 , "more text!"

{{out}}

"Some "
"Some text"
"Some more text!"

Kotlin

fun main(args: Array<String>) {
    val s1 = "James"
    val s2 = "Bond"
    println(s1)
    println(s2)
    val s3 = s1 + " " + s2
    println(s3)
}

{{Out}}

James
Bond
James Bond

LabVIEW

The two input on the left are String Controls, the output on the right is a String Indicator. All of them can be placed on the Front Panel. The Concatenate Strings function can be placed on the Block Diagram. You can switch between the Front Panel and the Block Diagram by pressing Ctrl+E.

[[File:LV_strcat.png]]

Lang5

: concat  2 compress "" join ;
'hello " literal" concat

Lasso

local(x = 'Hello')
local(y = #x + ', World!')
#x // Hello
#y // Hello, World!

Liberty BASIC

See [[#BASIC|BASIC]].

Lingo

a = "Hello"
b = a & " world!"
put b
-- "Hello world!"

Lisaac

Section Header

+ name := STRING_CONCATENATION;

Section Public

- main <- (
  + sc : STRING_CONSTANT;
  + sv : STRING;

  sc := "Hello";
  (sc + " literal").println;

  sv := sc + " literal";
  sv.println;

);

LiveCode

local str="live"
put str & "code" into str2
put str && str2

Output

live livecode

Logo

make "s "hello
print word :s "| there!|

Lua

a = "hello "
print(a .. "world")
c = a .. "world"
print(c)

M2000 Interpreter

M2000 Environment is an application written in Visual Basic 6, so can use strings UTF16LE (max 2GByte), and Ansi strings. So here is an example which add two Ansi strings. To print them to console we have to convert to UTF16LE. We can use ansi strings for files and for buffers (memory blocks). Conversion use Locale (so Locale 1032 can be used for Greek Ansi codepage)

A memory word is two bytes.

Module CheckString {
      s$ = "hello"
      PRINT s$;" literal" 'or s$ + " literal"
      s2$ = s$ + " literal"
      PRINT s2$
      Print Len(s2$)=13
      \\ get an ansi string
      k$=Str$("Hello")
      Print Len(k$)=2.5  ' 2.5 words or 5 bytes
      Print Chr$(k$)
      k2$=k$+Str$(" literal")
      Print Len(k2$)=6.5  ' 13 bytes
      Print Chr$(k2$)
      Print Len(Chr$(k2$))=13 ' words
}
CheckString

Maple

str := "Hello":
newstr := cat(str,", world!"):
str;
newstr;

{{out}}

                            "Hello"
                        "Hello, world!"

Mathematica

str= "Hello ";
str<>"Literal"

=={{header|MATLAB}} / {{header|Octave}}==

 string1 = '1 Fish'

string1 =

1 Fish

>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']

string2 =

1 Fish, 2 Fish, Red Fish, Blue Fish

Maxima

s: "the quick brown fox";
t: "jumps over the lazy dog";
sconcat(s, " ", t);
/* "the quick brown fox jumps over the lazy dog" */

Mercury

:- module string_concat.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module string.

main(!IO) :-
    S = "hello",
    S1 = S ++ " world",
    io.write_string(S, !IO), io.nl(!IO),
    io.write_string(S1, !IO), io.nl(!IO).

min

{{works with|min|0.19.3}}

"butter" :a
(a "scotch")=> "" join :b
a puts!
b puts!

{{out}}

butter
butterscotch

MiniScript

s = "hello"
print s + " world!"

{{output}}

hello world!

MUMPS

STRCAT
 SET S="STRING"
 WRITE !,S
 SET T=S_" LITERAL"
 WRITE !,T
 QUIT

{{out}}

CACHE>D STRCAT^ROSETTA

STRING
STRING LITERAL

M4

M4 has macros rather than variables, but a macro expanded can work like a variable.

define(`concat',`$1$2')dnl
define(`A',`any text value')dnl
concat(`A',` concatenated with string literal')
define(`B',`concat(`A',` and string literal')')dnl
B

MAXScript

s = "hello"
print (s + " literal")
s1 = s + " literal"
print s1

Metafont

string a, b;
a := "String";
message a & " literal";
b := a & " literal";
message b;

=={{header|Modula-3}}== Strings in Modula-3 are called TEXTs. Concatenation can use &, just like [[Ada]].

MODULE Concat EXPORTS Main;

IMPORT IO;

VAR string: TEXT := "String";
    string1: TEXT;

BEGIN
  IO.Put(string & " literal.\n");
  string1 := string & " literal.\n";
  IO.Put(string1);
END Concat.

Modula-3 also provides modules for dealing with TEXTs, such as Text.

string1 := Text.Concat(string, " literal.\n");

Neko

/**
 String concatenation, in Neko
 Tectonics:
    nekoc string-concatenation.neko
    neko string-concatenation [addon]
*/

var arg = $loader.args[0]
var addon
if arg != null addon = $string(arg)

var s = "abc"
$print("s: ", s, "\n")

var c = s + "def"
$print("c: ", c, "\n")

if arg != null {
    c += addon
    $print("addon: ", addon, "\n")
    $print("c: ", c, "\n")
}

{{out}}

prompt$ nekoc string-concatenation.neko
prompt$ neko string-concatenation.n xyz
s: abc
c: abcdef
addon: xyz
c: abcdefxyz

Nemerle

Can be done with Concat() method or + operator:

using System;
using System.Console;
using Nemerle.Utility.NString; // contains method Concat()

module Stringcat
{
    Main() : void
    {
        def text1 = "This string has";
        def cat1  = Concat( " ", [text, "been concatenated"]);
        def cat2  = text1 + " also been concatenated";
        Write($"$cat1\n$cat2\n");
    }
}

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols

s1 = 'any text value'
s2 = 'another string literal'
s3 = s1    s2 -- concatenate variables with blank space (note that only one blank space is added)
s4 = s1 || s2 -- concatenate variables with abuttal (here, no blank spaces are added)
s5 = s1    'another string literal' -- concatenate a variable and a literal with blank space
s6 = s1'another string literal'     -- concatenate a variable and a literal using abuttal
s7 = s1 || 'another string literal' -- ditto

say 's1:' s1 -- concatenation with blank space is employed here too
say 's2:' s2
say 's3:' s3
say 's4:' s4
say 's5:' s5
say 's6:' s6
say 's7:' s7

{{out}}

s1: any text value
s2: another string literal
s3: any text value another string literal
s4: any text valueanother string literal
s5: any text value another string literal
s6: any text valueanother string literal
s7: any text valueanother string literal

NewLISP

(let (str1 "foo")
     (println str1)
     (let (str2 (string str1 "bar"))
	  (println str2)))

Nim

Strings can be concatenated with &.

var str, str1 = "String"
echo(str & " literal.")
str1 = str1 & " literal."
echo(str1)

# -> String literal.

Strings can be concatenated as arrays and joined with a separating characters:

var str1 = "String"
echo(join([str1, " literal.", "HelloWorld!"], "~~"))

# -> String~~ literal.~~HelloWorld!

Strings can be combined using string formatting:

var str1 = "String"
echo "$# $# $#" % [str1, "literal.", "HelloWorld!"]

# -> String literal. HelloWorld!

=={{header|NS-HUBASIC}}== 10 STRING$="HELLO" 20 STRING$=STRING$+" WORLD!" 30 PRINT STRING$

## Objeck


```objeck
bundle Default {
  class Repeat {
    function : Main(args : String[]) ~ Nil {
      s := "hello";
      s->PrintLine();
      " literal"->PrintLine();
      s->Append(" literal");
      s->PrintLine();
    }
  }
}

=={{header|Objective-C}}==

int main()
{
  @autoreleasepool {

    NSString *s = @"hello";
    printf("%s%s\n", [s UTF8String], " literal");

    NSString *s2 = [s stringByAppendingString:@" literal"];
    // or, NSString *s2 = [NSString stringWithFormat:@"%@%@", s, @" literal"];
    puts([s2 UTF8String]);
    /* or */
    NSMutableString *s3 = [NSMutableString stringWithString: s];
    [s3 appendString: @" literal"];
    puts([s3 UTF8String]);

  }
  return 0;
}

OCaml

let s = "hello"
let s1 = s ^ " literal"
let () =
  print_endline (s ^ " literal");
  print_endline s1

Oforth

.s show the stack :

"Hello" dup " World!" + .s

{{out}}

[1] (String) Hello World!
[2] (String) Hello

Openscad

a="straw";
b="berry";
c=str(a,b);    /* Concatenate a and b */
echo (c);

Oz

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. [http://www.mozart-oz.org/home/doc/base/virtualstring.html "Virtual string are designed as a convenient way to combine strings, byte strings, atoms, integers and floats to compound strings without explicit concatenation and conversion"].

declare
S = "hello"
{System.showInfo S#" literal"} %% virtual strings are constructed with "#"
S1 = {Append S " literal"}
{System.showInfo S1}

PARI/GP

s = "Hello ";
s = Str(s, "world");
\\ Alternately, this could have been:
\\ s = concat(s, "world");
print(s);

Pascal

Program StringConcat;
  Var
     s, s1   : String;

Begin
    s := 'hello';
    writeln(s + ' literal');
    s1 := concat(s, ' literal');
    { s1 := s + ' literal'; works too, with FreePascal }
    writeln(s1);
End.

Perl

my $s = 'hello';
print $s . ' literal', "\n";
my $s1 = $s . ' literal';
print $s1, "\n";

An example of destructive concatenation:

$s .= ' literal';
print $s, "\n";

Perl 6

{{works with|Rakudo|#22 "Thousand Oaks"}}

my $s = 'hello';
say $s ~ ' literal';
my $s1 = $s ~ ' literal';
say $s1;

# or, using mutating concatenation:

$s ~= ' literal';
say $s;

Note also that most concatenation in Perl 6 is done implicitly via interpolation.

Phix

string s1 = "at"                                ?s1
string s2 = "c"&s1                              ?s2
string s3 = "s"&s1                              ?s3
string s4 = "m"&s1                              ?s4
string s5 = "The "&s2&" "&s3&" on the "&s4&"."  ?s5

{{out}}

"at"
"cat"
"sat"
"mat"
"The cat sat on the mat."

PHL

module stringcat;

extern printf;

@Integer main [ var a = "hello"; var b = a + " literal"; printf("%s\n", b);

return 0;

]

## PHP


```php
<?php
$s = "hello";
echo $s . " literal" . "\n";
$s1 = $s . " literal";
echo $s1 . "\n";
?>

PicoLisp

(let Str1 "First text"
   (prinl Str1 " literal")
   (let Str2 (pack Str1 " literal")
      (prinl Str2) ) )

PL/I

declare (s, t) character (30) varying;

s = 'hello from me';
display (s || ' to you.' );
t = s || ' to you all';
display (t);

PowerShell

$s = "Hello"
Write-Host $s World.

# alternative, using variable expansion in strings
Write-Host "$s World."

$s2 = $s + " World."
Write-Host $s2

PureBasic

If OpenConsole()

  s$ = "hello"
  PrintN( s$ + " literal")
  s2$ = s$ + " literal"
  PrintN(s2$)

  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
  Input()
  CloseConsole()
EndIf

Python

s1 = "hello"
print s1 + " world"

s2 = s1 + " world"
print s2

{{out}}

hello world
hello world

When concatenating many strings, it is more efficient to use the join method of a string object, which takes a list of strings to be joined. The string on which join is called is used as a separator.

s1 = "hello"
print ", ".join([s1, "world", "mom"])

s2 = ", ".join([s1, "world", "mom"])
print s2

{{out}}

hello, world, mom
hello, world, mom

R

hello <- "hello"
paste(hello, "literal") # "hello literal"
hl <- paste(hello, "literal") #saves concatenates string to a new variable
paste("no", "spaces", "between", "words", sep="") # "nospacesbetweenwords"

Racket

#lang racket
(define hello "hello")
(displayln hello)

(define world (string-append hello " " "world" "!"))
(displayln world)

;outputs:
;  hello
;  hello world!

Raven

# Cat strings
"First string and " "second string" cat print

# Join
[ "First string" "second string" "third string" ] " and " join print

# print
[ "First string" "second string" "third string" ] each print

# Formatted print
"\n" "Third string" "Second string" "First string" "%s %s %s %s" print

# Heredoc
" - NOT!!" as $x
"This is the only way to do it%($x)s" print

{{out}}

First string and second string
First string and second string and third string
First stringsecond stringthird string
First string Second string Third string

This is the only way to do it - NOT!!

REBOL

s: "hello"
print s1: rejoin [s " literal"]
print s1

Red

str1: "Hello"
>>str2: append str1 " World"
>> print str2
Hello World
>> print str1
Hello World

REXX

s = "hello"
say s "literal"
t = s "literal"    /* Whitespace between the two strings causes a space in the output */
say t

                        /* The above method works without spaces too */
genus="straw"
say genus"berry"        /* This outputs strawberry */
say genus || "berry"    /* Concatenation using a doublepipe does not cause spaces */

Retro

with strings'
"hello" "literal" append puts

Ring

aString = "Welcome to the "
bString = "Ring Programming Language"

see astring + bString + nl

Ruby

s = "hello"
p s + " literal"        #=> "hello literal"
s1 = s + " literal"
p s1                    #=> "hello literal"
s1 << " another" # append to s1
p s1                    #=> "hello literal another"

s = "hello"
p s.concat(" literal")  #=> "hello literal"
p s                     #=> "hello literal"

Rust

fn main() {
    let s = "hello".to_owned();
    println!("{}", s);

    let s1 = s + " world";
    println!("{}", s1);
}

SAS

data _null_;
   a="Hello,";
   b="World!";
   c=a !! " " !! b;
   put c;
   *Alternative using the catx function;
   c=catx (" ", a, b);
   put c;
run;

Sather

class MAIN is
  main is
    s ::= "hello";
    #OUT + s + " literal\n";
    s2 ::= s + " literal";
    #OUT + s2 + "\n";
  end;
end;

Scala

Evaluation in a Scala worksheet, to val f2 is an anonymous function assigned.

  val s = "hello"                                 //> s  : String = hello
  val s2 = s + " world"                           //> s2  : String = hello world
  val f2 = () =>  " !"                            //> f2  : () => String = <function0>

  println(s2 + f2())                              //> hello world !

Scheme

(define s "hello")
(display (string-append s " literal"))
(newline)
(define s1 (string-append s " literal"))
(display s1)
(newline)

Scilab

s1="Hello" s1+" world!" s2=s1+" world" s2

{{out}}
<pre style="height:20ex> --> s1="Hello"
 s1  =
 Hello
 -->s1+" world!"
 ans  =
 Hello world!
 -->s2=s1+" world!"
 s2  =
 Hello world!
 -->s2
 Hello world!

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  local
    var string: s is "hello";
    var string: s2 is "";
  begin
    writeln(s <& " world");
    s2 := s & " world";
    writeln(s2);
  end func;

{{out}}

hello world
hello world

Sidef

var s = 'hello';
say s+' literal';
var s1 = s+' literal';
say s1;

An example of destructive concatenation:

s += ' literal';
say s;

Simula

TEXT PROCEDURE concatenate(head, tail);
    TEXT head, tail;
BEGIN TEXT c;
    c :- blanks(head.length + tail.length);
    c.sub(c.start, head.length) := head; ! putText(), anyone?;
    c.sub(c.start + head.length, tail.length) := tail;
    concatenate:- c;
END;

TEXT stringVariable, another;
stringVariable :- "head ";
another :- concatenate(stringVariable, "and tail");
OutText("stringVariable: """); OutText(stringVariable);
OutText(""", another: "); OutText(another); Outimage;

Slate

define: #s -> 'hello'.
inform: s ; ' literal'.
define: #s1 -> (s ; ' literal').
inform: s1.

Smalltalk

|s s1| s := 'hello'.
(s,' literal') printNl.
s1 := s,' literal'.
s1 printNl.

SNOBOL4

	greet1 = "Hello, "
	output = greet1
	greet2 = greet1 "World!"
	output = greet2
end

Sparkling

let s1 = "Hello";
let s2 = " world!";
print(s1 .. s2); // prints "Hello world!"

Standard ML

val s = "hello"
val s1 = s ^ " literal\n"
val () =
  print (s ^ " literal\n");
  print s1

Stata

Stata string scalars

sca a = "foo"
sca b = "bar"
sca c = a+b
di c
  foobar

Mata

a = "foo"
b = "bar"
c = a+b
c
  foobar

Swift

let s = "hello"
println(s + " literal")
let s1 = s + " literal"
println(s1)

Tcl

set s hello
puts "$s there!"
append s " there!"
puts $s

You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation:

set s "Hello "
set t "World"
set u "!"
puts $s$t$u  ;# There is nothing special here about using puts; just an example

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

"HELLO"→Str0
Str0+" WORLD!"→Str0

{{out}}

HELLO WORLD!

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

"aard" → sv
Disp sv & "vark"
sv & "wolf" → sv2

TorqueScript

%string = "Hello";
echo(%string);
%other = " world!";
echo(%other);
echo(%string @ %other);

TUSCRIPT

$$ MODE TUSCRIPT
s = "Hello "
print s, "literal"

s1 = CONCAT (s,"literal")
print s1

{{out}}

Hello literal
Hello literal

UNIX Shell

{{works with|Bourne Shell}} {{works with|bash}}

s="hello"
echo "$s literal"
s1="$s literal"    # This method only works with a space between the strings
echo $s1

# To concatenate without the space we need squiggly brackets:
genus='straw'
fruit=${genus}berry  # This outputs the word strawberry
echo $fruit

UnixPipes

echo "hello"
 | xargs -n1 -i echo {} literal

Ursa

decl string s1 s2
# make s1 contain "hello "
set s1 "hello "

# set s2 to contain s1 and "world"
set s2 (+ s1 "world")

# outputs "hello world"
out s2 endl console

Visual Basic

{{works with|Visual Basic|VB6 Standard}} works the same as in VBA, see [[String_concatenation#VBA]]

Visual Basic .NET

'''Platform:''' [[.NET]] {{works with|Visual Basic .NET|9.0+}}

s = "Hello"
Console.WriteLine(s & " literal")
s1 = s + " literal"
Console.WriteLine(s1)

VBA

Option Explicit

Sub String_Concatenation()
Dim str1 As String, str2 As String

    str1 = "Rosetta"
    Debug.Print str1
    Debug.Print str1 & " code!"
    str2 = str1 & " code..."
    Debug.Print str2 & " based on concatenation of : " & str1 & " and code..."
End Sub

{{out}}

Rosetta
Rosetta code!
Rosetta code... based on concatenation of : Rosetta and code...

Wee Basic

let string1$="Hello "
let string2$="world!"
print 1 string1$+string2$
end

XPL0

func Concat(S1, S2, S3);        \Concatenate strings: S3:= S1 + S2
char S1, S2, S3;
int  C, I, J;
[I:= 0;
repeat  C:= S1(I);
        S3(I):= C & $7F;        \remove MSb terminator from first string
        I:= I+1;
until   C >= $80;
J:= 0;
repeat  C:= S2(J);
        S3(I+J):= C;
        J:= J+1;
until   C >= $80;
return S3;
];

code Text=12;
char A, B, C(80);
[A:= "Hello";
 B:= " World!";
Concat(A, B, C);
Text(0, C);
]

Yorick

var1 = "Hello";
var2 = var1 + ", world!";
write, var1;
write, var2;

zkl

var s="Hello";
s2:=s+", world!"; s2.println(); //-->Hello, world!
s3:=String(s," ",s2); s3.println(); //-->Hello Hello, world!

{{omit from|bc|No string operations in bc}} {{omit from|dc|No string operations in dc}} [[Wikipedia::https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#Concatenation]]