String prepend

Task

Create a string variable equal to any text value.

Prepend the string variable with another string literal.

If your language supports any idiomatic ways to do this without referring to the variable twice in one expression, include such solutions.

To illustrate the operation, show the content of the variable.

11l

Translation of: Python

<lang 11l>V s = ‘12345678’ s = ‘0’s print(s)</lang>

Output:

012345678

360 Assembly

<lang 360asm>* String prepend - 14/04/2020 PREPEND CSECT

        USING  PREPEND,13         base register
        B      72(15)             skip savearea
        DC     17F'0'             savearea
        SAVE   (14,12)            save previous context
        ST     13,4(15)           link backward
        ST     15,8(13)           link forward
        LR     13,15              set addressability
        MVC    C+L'B(L'A),A       c=a
        MVC    C(L'B),B           c=b+c  (prepend)
        XPRNT  C,L'C              print buffer
        L      13,4(0,13)         restore previous savearea pointer
        RETURN (14,12),RC=0       restore registers from calling sav

A DC C'world!' a B DC C'Hello ' b C DC CL80' ' c

        END    PREPEND</lang>

Output:

Hello world!

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

<lang AArch64 Assembly> /* ARM assembly AARCH64 Raspberry PI 3B */ /* program appendstr64.s */

/*******************************************/ /* Constantes file */ /*******************************************/ /* for this file see task include a file in language AArch64 assembly*/ .include "../includeConstantesARM64.inc"

/*******************************************/ /* Initialized data */ /*******************************************/ .data szMessString: .asciz "British Museum.\n" szComplement: .skip 80 szStringStart: .asciz "The rosetta stone is at " szCarriageReturn: .asciz "\n" /*******************************************/ /* UnInitialized data */ /*******************************************/ .bss /*******************************************/ /* code section */ /*******************************************/ .text .global main main:

   ldr x0,qAdrszMessString               // display message
   bl affichageMess

   ldr x0,qAdrszMessString
   ldr x1,qAdrszStringStart
   bl prepend                             // append sting2 to string1
   ldr x0,qAdrszMessString
   bl affichageMess

   ldr x0,qAdrszCarriageReturn
   bl affichageMess

100: // standard end of the program

   mov x0,0                              // return code
   mov x8,EXIT                           // request to exit program
   svc 0                                 // perform system call

qAdrszMessString: .quad szMessString qAdrszStringStart: .quad szStringStart qAdrszCarriageReturn: .quad szCarriageReturn /**************************************************/ /* append two strings */ /**************************************************/ /* x0 contains the address of the string1 */ /* x1 contains the address of the string2 */ prepend:

   stp x1,lr,[sp,-16]!            // save  registers
   mov x3,#0                                // length counter

1: // compute length of string 1

   ldrb w4,[x0,x3]
   cmp w4,#0
   cinc  x3,x3,ne                           // increment to one if not equal
   bne 1b                                   // loop if not equal
   mov x5,#0                                // length counter insertion string

2: // compute length of insertion string

   ldrb w4,[x1,x5]
   cmp x4,#0
   cinc  x5,x5,ne                           // increment to one if not equal
   bne 2b
   cmp x5,#0
   beq 99f                                  // string empty -> error
   add x3,x3,x5                             // add 2 length
   add x3,x3,#1                             // +1 for final zero
   mov x6,x0                                // save address string 1
   mov x0,#0                                // allocation place heap
   mov x8,BRK                               // call system 'brk'
   svc #0
   mov x5,x0                                // save address heap for output string
   add x0,x0,x3                             // reservation place x3 length
   mov x8,BRK                               // call system 'brk'
   svc #0
   cmp x0,#-1                               // allocation error
   beq 99f
   mov x4,#0                      // counter byte string 2

3:

   ldrb w3,[x1,x4]                // load byte string 2
   cbz x3,4f                      // zero final ?
   strb w3,[x5,x4]                // store byte string 2 in heap
   add x4,x4,1                    // increment counter 1
   b 3b                           // no -> loop

4:

   mov x2,#0                      // counter byte string 1

5:

   ldrb w3,[x6,x2]                // load byte string 1
   strb w3,[x5,x4]                // store byte string in heap
   cbz x3,6f                    // zero final ?
   add x2,x2,1                    // no -> increment counter 1
   add x4,x4,1                    // no -> increment counter 2
   b 5b                           // no -> loop

6: // recopie heap in string 1

   mov x2,#0                      // counter byte string

7:

   ldrb w3,[x5,x2]                // load byte string in heap
   strb w3,[x6,x2]                // store byte string 1
   cbz x3,100f                    // zero final ?
   add x2,x2,1                    // no -> increment counter 1
   b 7b                           // no -> loop

100:

   ldp x1,lr,[sp],16              // restaur  2 registers
   ret                            // return to address lr x30

/********************************************************/ /* File Include fonctions */ /********************************************************/ /* for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc" </lang>

Output:

British Museum.
The rosetta stone is at British Museum.

Action!

<lang Action!>PROC Append(CHAR ARRAY text,suffix)

 BYTE POINTER srcPtr,dstPtr
 BYTE len

 len=suffix(0)
 IF text(0)+len>255 THEN
   len=255-text(0)
 FI
 IF len THEN
   srcPtr=suffix+1
   dstPtr=text+text(0)+1
   MoveBlock(dstPtr,srcPtr,len)
   text(0)==+suffix(0)
 FI

RETURN

PROC Prepend(CHAR ARRAY text,prefix)

 CHAR ARRAY tmp(256)

 SCopy(tmp,text)
 SCopy(text,prefix)
 Append(text,tmp)

RETURN

PROC TestPrepend(CHAR ARRAY text,preffix)

 PrintF("Source ""%S"" at address %H%E",text,text)
 PrintF("Prepend ""%S""%E",preffix)
 Prepend(text,preffix)
 PrintF("Result ""%S"" at address %H%E",text,text)
 PutE()

RETURN

PROC Main()

 CHAR ARRAY text(256)

 text(0)=0
 TestPrepend(text,"World!")
 TestPrepend(text,"Hello ")

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

Source "" at address $2A8A
Prepend "World!"
Result "World!" at address $2A8A

Source "World!" at address $2A8A
Prepend "Hello "
Result "Hello World!" at address $2A8A

Ada

In Ada, a variable of type String cannot change its length. So the variable S which we will change, need to be of the type Unbounded_String. Thus the need for conversions from String literal to Unbounded_String for initialization, and from Unbounded_String to String for printing.

<lang Ada>with Ada.Text_IO; with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

procedure Prepend_String is

  S: Unbounded_String := To_Unbounded_String("World!");

begin

  S := "Hello " & S;-- this is the operation to prepend "Hello " to S. 
  Ada.Text_IO.Put_Line(To_String(S));

end Prepend_String;</lang>

Output:

Hello World!

ALGOL 68

Works with: ALGOL 68 version Revision 1.

Works with: ALGOL 68G version Any - tested with release algol68g-2.7.

Works with: ELLA ALGOL 68 version Any (with appropriate job cards).

File: String_prepend.a68<lang algol68>#!/usr/bin/a68g --script #

-*- coding: utf-8 -*- #

STRING str := "12345678"; "0" +=: str; print(str)</lang>

Output:

012345678

AppleScript

AppleScript text is immutable, so prepending is only possible by creating a new text through concatenation of the variable's existing contents to the other string:

<lang applescript>set aVariable to "world!" set aVariable to "Hello " & aVariable return aVariable</lang>

Output:

<lang applescript>"Hello world!"</lang>

It's a similar situation with NSString class in AppleScriptObjC. This has various ways of achieving the same thing, probably the most sensible of which is the first of the following:

<lang applescript>use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later use framework "Foundation"

set aVariable to current application's class "NSString"'s stringWithString:("world!") set aVariable to aVariable's stringByReplacingCharactersInRange:({0, 0}) withString:("Hello ") -- return aVariable as text

-- Or: set aVariable to current application's class "NSString"'s stringWithString:("world!") set aVariable to current application's class "NSString"'s stringWithFormat_("%@%@", "Hello ", aVariable) -- return aVariable as text

-- Or: set aVariable to current application's class "NSString"'s stringWithString:("world!") set aVariable to aVariable's stringByReplacingOccurrencesOfString:("^") withString:("Hello ") ¬

   options:(current application's NSRegularExpressionSearch) range:({0, 0})

-- return aVariable as text</lang>

But there's also an NSMutableString class. This has 'replace' versions of the 'stringByReplacing' methods above and also this insertString:atIndex: method:

<lang applescript>use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later use framework "Foundation"

set aVariable to current application's class "NSMutableString"'s stringWithString:("world!") tell aVariable to insertString:("Hello ") atIndex:(0) return aVariable as text</lang>

Output:

<lang applescript>"Hello world!"</lang>

Arturo

<lang rebol>a: "World" a: "Hello" ++ a print a

b: "World" b: append "Hello" b print a

c: "World" prefix 'c "Hello" print c

d: "World" print prefix d "Hello"</lang>

Output:

HelloWorld
HelloWorld
HelloWorld
HelloWorld

Asymptote

<lang Asymptote>string s1 = " World!"; write("Hello" + s1); write("Hello", s1); string s2 = "Hello" + s1; write(s2);</lang>

AutoHotkey

<lang autohotkey>s := "foo" s := s "bar" Msgbox % s</lang>

Output:

foobar

AWK

syntax: GAWK -f STRING_PREPEND.AWK

BEGIN {

   s = "bar"
   s = "foo" s
   print(s)
   exit(0)

} </lang>

Output:

foobar

BaCon

<lang bacon>s$ = "prepend" s$ = "String " & s$ PRINT s$</lang>

Output:

String prepend

BASIC

<lang BBC BASIC>S$ = " World!" S$ = "Hello" + S$ PRINT S$ </lang>

Output:

Hello World!

Applesoft BASIC

<lang Applesoft BASIC>100 LET S$=" World!" 110 LET S$="Hello"+S$ 120 PRINT S$</lang>

BASIC256

<lang basic256>a$ = " World!" a$ = "Hello"; a$ print a$

would also be valid

a$ = "Hello" + a$

and

a$ = "Hello" & a$</lang>

IS-BASIC

<lang IS-BASIC>100 LET S$=" World!" 110 LET S$="Hello"&S$ 120 PRINT S$</lang>

Run BASIC

Works with: BASIC256

Works with: Liberty BASIC

Works with: QB64

Works with: QBasic

Works with: Yabasic

<lang runbasic>a$ = " World!" a$ = "Hello" + a$ print a$

' en RB, LB and BASIC256 would also be valid a$ = "Hello"; a$</lang>

True BASIC

Works with: BASIC256

<lang qbasic>LET a$ = " World!" LET a$ = "Hello" & a$ PRINT a$ END</lang>

Yabasic

Works with: BASIC256

Works with: Liberty BASIC

Works with: QB64

Works with: QBasic

Works with: Run BASIC

<lang freebasic>a$ = " World!" a$ = "Hello" + a$ print a$</lang>

Bracmat

<lang bracmat> World!:?string & str$("Hello " !string):?string & out$!string</lang>

Hello World!

C

<lang c>#include<stdio.h>

include<string.h>
include<stdlib.h>

int main() {

   char str[100]="my String";
   char *cstr="Changed ";
   char *dup;
   sprintf(str,"%s%s",cstr,(dup=strdup(str)));
   free(dup);
   printf("%s\n",str);
   return 0;

}</lang>

Output:

Changed my String

C#

<lang csharp>using System;

namespace PrependString {

   class Program
   {
       static void Main(string[] args)
       {
           string str = "World";
           str = "Hello " + str;
           Console.WriteLine(str);
           Console.ReadKey();
       }
   }

}</lang>

Hello World

C++

<lang cpp>include <vector>

include <algorithm>
include <string>
include <iostream>

int main( ) {

  std::vector<std::string> myStrings { "prepended to" , "my string" } ;
  std::string prepended = std::accumulate( myStrings.begin( ) ,

myStrings.end( ) , std::string( "" ) , []( std::string a , std::string b ) { return a + b ; } ) ;

  std::cout << prepended << std::endl ;
  return 0 ;

}</lang>

Output:

prepended tomy string

Clojure

A pure function implementation with immutability

<lang clojure> (defn str-prepend [a-string, to-prepend]

 (str to-prepend a-string))

</lang>

REPL demonstrations with mutability in mind

a) with the atom data structure

<lang clojure> (def s (atom "World")) (swap! s #(str "Hello, " %))

user=> @s user=> "Hello, Wolrd" </lang>

b) with the ref data structure <lang clojure> (def s (ref "World")) (dosync (alter s #(str "Hello " %)))

user=> @s user=> "Hello World" </lang>

COBOL

<lang COBOL> identification division.

      program-id. prepend.
      data division.
      working-storage section.
      1 str pic x(30) value "World!".
      1 binary.
       2 len pic 9(4) value 0.
       2 scratch pic 9(4) value 0.
      procedure division.
      begin.
          perform rev-sub-str
          move function reverse ("Hello ") to str (len + 1:)
          perform rev-sub-str
          display str
          stop run
          .

      rev-sub-str.
          move 0 to len scratch
          inspect function reverse (str)
          tallying scratch for leading spaces
              len for characters after space
          move function reverse (str (1:len)) to str
          .
      end program prepend.</lang>

Hello World!

Works with: GNU Cobol version 2.0

<lang cobol> >>SOURCE FREE PROGRAM-ID. prepend.

DATA DIVISION. WORKING-STORAGE SECTION. 01 str PIC X(30) VALUE "world!".

PROCEDURE DIVISION.

   MOVE FUNCTION CONCATENATE("Hello, ", str) TO str
   DISPLAY str
   .

END PROGRAM prepend.</lang>

ColdFusion

Classic tag based CFML

<lang cfm> <cfoutput> <cfset who = "World!"> #"Hello " & who# </cfoutput> </lang>

Output:

Hello World!

Script Based CFML

<lang cfm><cfscript> who = "World!"; greeting = "Hello " & who; writeOutput( greeting ); </cfscript></lang>

Output:

Hello World!

Common Lisp

A macro is necessary in order to prepend a string in-place: <lang lisp>(defmacro prependf (s &rest strs)

 "Prepend the given string variable with additional strings. The string variable is modified in-place."
 `(setf ,s (concatenate 'string ,@strs ,s)))

(defvar *str* "foo") (prependf *str* "bar") (format T "~a~%" *str*)</lang>

Output:

barfoo

D

<lang d>import std.stdio;

void main() {

   string s = "world!";
   s = "Hello " ~ s; 
   writeln(s);

}</lang>

Output:

Hello world!

Delphi

Library: System.SysUtils

<lang Delphi> program String_preappend;

{$APPTYPE CONSOLE}

uses

 System.SysUtils;

type

 TStringHelper = record helper for string
   procedure Preappend(str: string);
 end;

{ TStringHelper }

procedure TStringHelper.Preappend(str: string); begin

 Self := str + self;

end;

begin

 var h: string;

 // with + operator
 h := 'World';
 h := 'Hello ' + h;
 writeln(h);

 // with a function concat
 h := 'World';
 h := concat('Hello ', h);
 writeln(h);

 // with helper
 h := 'World';
 h.Preappend('Hello ');
 writeln(h);
 readln;

end.</lang>

Output:

Hello World
Hello World
Hello World

Dyalect

<lang Dyalect>var s = "world!" s = "Hello " + s print(s)</lang>

Déjà Vu

<lang dejavu>local :s "world!" set :s concat( "Hello " s) !print s</lang>

Output:

Hello world!

EchoLisp

<lang scheme> define-syntax-rule

   (set!-string-prepend a before) 
   (set! a (string-append before a)))
  → #syntax:set!-string-prepend

(define name "Presley")

   → name

(set!-string-prepend name "Elvis ") name

   → "Elvis Presley"

</lang>

Elena

ELENA 4.x: <lang elena>import extensions; import extensions'text;

public program() {

   var s := "World";
   s := "Hello " + s;
   console.writeLine:s;

   // Alternative way
   var s2 := StringWriter.load("World");
   s2.insert(0, "Hello ");
   console.writeLine:s2;
   console.readChar()

}</lang>

Elixir

<lang Elixir> str1 = "World!" str = "Hello, " <> str1 </lang>

Output:

"Hello, World!"

Emacs Lisp

While strings in Emacs Lisp are mutable, they're fixed size. Therefore the concat function creates a new string and the existing string must be referenced twice:

<lang Lisp>(defvar str "bar") (setq str (concat "foo" str)) str ;=> "foobar"</lang>

This can be hidden by using a macro such as cl-callf2 which expands into the above code:

Library: cl-lib

<lang Lisp>(require 'cl-lib)

(defvar str "bar") (cl-callf2 concat "foo" str) str ;=> "foobar"</lang>

Buffers can be thought of as expandable strings:

<lang Lisp>(let ((buf (get-buffer-create "*foo*")))

 (with-current-buffer buf
   (insert "bar"))
 (with-current-buffer buf
   (goto-char (point-min))
   (insert "foo")
   (buffer-string)))

=> "foobar"</lang>

Erlang

Output:

1> S = "world".
"world"
2> "Hello " ++ S.
"Hello world"

ERRE

<lang ERRE> ...... S$=" World!" S$="Hello"+S$ PRINT(S$) ...... </lang>

Output:

Hello World!

F#

<lang fsharp>let mutable s = "world!" s <- "Hello, " + s printfn "%s" s</lang>

Factor

<lang factor> "world" "Hello " prepend </lang>

Falcon

VBA/Python programmer's approach not sure if it's the most falconic way <lang falcon> /* created by Aykayayciti Earl Lamont Montgomery April 9th, 2018 */

s = "fun " s = s + "Falcon" > s </lang>

Output:

fun Falcon
[Finished in 0.2s]

Forth

Forth has no string prepend word, but adding it is not difficult. This demonstration starts from the low level operations that Forth gives us and quickly builds a simple set of "WORDS" (sub-routines) that let us move strings from address to address. Strings are just an address on the data stack so we can reference them as many times as we need to. Our prepend word makes use of the Return stack as a temporary storage for the address of the string we want to prepend. Standard Forth also provides a named general purpose buffer called PAD, so we make use of that too. With this PREPEND becomes part of the language.

<lang>\ the following functions are commonly native to a Forth system. Shown for completeness

C+! ( n addr -- ) dup c@ rot + swap c! ; \ primitive: increment a byte at addr by n

+PLACE ( addr1 length addr2 -- ) \ Append addr1 length to addr2

         2dup 2>r  count + swap move 2r> c+! ;

PLACE ( addr1 len addr2 -- ) \ addr1 and length, placed at addr2 as counted string

         2dup 2>r  1+  swap  move  2r> c! ;

\ Example begins here

PREPEND ( addr len addr2 -- addr2)

          >R                                              \ push addr2 to return stack
          PAD PLACE                                       \ place the 1st string in PAD
          R@  count PAD +PLACE                            \ append PAD with addr2 string
          PAD count R@   PLACE                            \ move the whole thing back into addr2
          R> ;                                            \ leave a copy of addr2 on the data stack

writeln ( addr -- ) cr count type ; \ syntax sugar for testing</lang>

Test our language extensions interactively at the console

256 buffer: string1 ok                                     
s" needs no introduction!" string1 place  ok                
string1 writeln 
needs no introduction! ok

s" This string "  string1 prepend writeln
This string needs no introduction! ok

Fortran

Early inability

Early Fortran had almost no ability to manipulate text except via overwriting text literals in a FORMAT statement used in a READ, that would then appear when the same FORMAT statement was used in a WRITE (!) perhaps as a heading.

Initial difficulty

With Fortran IV came the ability to use arrays of integers and the A1 format code in READ and WRITE statements for them. With sixteen-bit integers, one might use A2 and so forth, but the numerical values of the integers would not be convenient especially if the sign bit was involved. This would be even more difficult with floating-point variables. Still, the desire for good headings and annotations and flexible layout flogged one onwards. Following the Pascal "Hello world!" example, one might proceed somewhat as follows:<lang Fortran> INTEGER*4 I,TEXT(66)

     DATA TEXT(1),TEXT(2),TEXT(3)/"Wo","rl","d!"/

     WRITE (6,1) (TEXT(I), I = 1,3)
   1 FORMAT ("Hello ",66A2)

     DO 2 I = 1,3
   2   TEXT(I + 3) = TEXT(I)
     TEXT(1) = "He"
     TEXT(2) = "ll"
     TEXT(3) = "o "

     WRITE (6,3) (TEXT(I), I = 1,6)
   3 FORMAT (66A2)
     END</lang>

This old-style source is acceptable to the F90 compiler as it stands. By chance, two characters per integer fits nicely but in many cases having one character per variable is easier for manipulation. So, as usual with Fortran, it's all done with arrays. The DATA statement demonstrates that a quoted string is acceptable as a value for an integer; it is just a matter of bit patterns, and this type miscegnation will work with floating-point variables also though resulting in even stranger numerical values. Looking more closely, note that an INTEGER*4 variable can hold four eight-bit characters but only two-character text literals have been specified. Unlike integer constants, which might be considered to have leading zero digits, text literals are deemed to have trailing spaces as needed: "Wo" is deemed to be "Wo " to make up to the recipient's capacity for four characters, and when format code A2 is specified, the leftmost two characters in the variable are taken. The strange ideas of "little-endianism" have never flourished on mainframes! Thus, if the format code were to be A4, then "Wo " would appear, not " Wo".

The first output (to standard output: unit 6) thus prepends the text "Hello " via the workings of the nominated FORMAT statement without a further mention of variable TEXT, itself not being modified in this action. Thus, this is an example of a single-mention possibility.

Some versions of Fortran offered the ability to write to a variable such as an array rather than to a nominated output unit, via a statement like WRITE (TEXT,1) (TEXT(I),I = 1,3), which array could then itself be written to the actual output via normal statements. This would involve a working variable within the routines for formatted I/O to hold the output, and thus provides one of the reasons that Fortran I/O implementations seldom enable re-entrancy - as with a WRITE statement whose output expression list includes a function evaluation, which function itself attempts to WRITE something, say to a log file, with both WRITE statements employing formatting statements. More modern compilers now require the recipient for this sort of WRITE statement to be of type CHARACTER, so the older style is blocked - and re-entrancy is still a problem.

Still another variant involved writing to unit number zero, which did not actually send anything to an output recipient. Instead, the scratchpad used by the formatted I/O system would retain whatever was produced, which could then be read back via unit number zero. Indeed, reading from unit zero would reveal whatever had been the last line of the previous I/O statement. This would be of interest if a format error had been reported on a READ during some mass data acquisition, so that the error message could show the problematic input that had been obtained rather than just complain. But this facility was not common, and did not become a part of the F90 standard. Perhaps a BACKSPACE and re-read to a text variable will work instead...

Retreating from FORMAT usage to the case of manipulating a "string" variable so as to prepend a given text to the working variable, first the existing content must be moved right to make room (again, an even number of characters is involved) which is achieved via the DO-loop, using certain constants. If on the other hand, text were to be removed from the front, then a loop would be needed to shift the surviving content leftwards. In doing this, one must pay attention to any overlaps and the direction of the loop! By chance, this exercise starts the placement after the end of the existing text but if instead the shift were to be two units, then the first-placed unit would land atop the tail end of the existing text. Thus, for rightwards shifts, one should start with the end of the surviving text and work back to its start.

Having made space, the next statements merely assign some bit patterns to elements of TEXT, and then the result is revealed, again using known constants instead of the associated variables of the more general approach. The result from the two WRITE statements is of course

Hello world!
Hello world!

Character facility

With F77 came the CHARACTER type... <lang Fortran> CHARACTER*66 TEXT

     TEXT = "World!"
     TEXT = "Hello "//TEXT
     WRITE (6,*) TEXT
     END </lang>

This means that variable TEXT has space for 66 characters, addressed as TEXT(first:last) starting with one. There is no associated string length facility, so the first assignment places the six characters of the supplied literal, followed by spaces all the way to the end of TEXT. Alternatively, TEXT(1:6) = "World!" would place only six characters, leaving the rest of TEXT to hold whatever it may. This would probably be unsuitable for the next statement, which prepends "Hello " to the content of TEXT (including positions past six) and assigns the result to TEXT, overwriting its previous content - with the aid of a temporary working area. Although in principle there could be cunning schemes that update the recipient "in place" with a minimum of character copying to and fro, this doesn't happen. Only characters up to the capacity of the recipient will be transferred from the expression's result, and if the result is shorter than the capacity of the recipient, trailing spaces will be added. All of this is extra effort! And when TEXT is written out, all 66 characters will be sent forth. It is useful to have a function that locates the last non-blank character!

Modern

With F90, and standardised in F2003, came extensions that enable a variable to be "cut-to-fit" on each usage. The first assignment would discard any storage associated with TEXT and re-assign space matching the size of the expression's result, so TEXT would have six characters. In the next statement, the expression would be evaluated and produce twelve characters (six from "Hello ", and the six of the current size of TEXT), then the current storage for text would be discarded and TEXT re-allocated to be of size twelve. At some cost in overhead. On the other hand, rather than copy the result of an expression from the scratchpad to the recipient, with re-allocation, the recipient variable could be repointed to the result area: no copying needed.

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Var s = "prepend" s = "String " + s Print s Sleep</lang>

Output:

String prepend

Gambas

Click this link to run this code <lang gambas>Public Sub Main() Dim sString1 As String = "world!" Dim sString2 As String = "Hello "

sString1 = sString2 & sString1

Print sString1

End</lang> Output:

Hello world!

Go

<lang go>s := "world!" s = "Hello, " + s</lang>

Haskell

<lang haskell> Prelude> let f = (++" World!") Prelude> f "Hello" </lang>

Output:

"Hello world!"

Icon and Unicon

<lang unicon>s := "world!" s := "Hello, " || s</lang>

To demonstrate how this could be done with only one reference to the variable during the prepend:

<lang unicon>procedure main()

  s := ", world"
  s[1:1] ||:= "Hello"
  write(s)

end</lang>

Output:

prompt$ unicon -s prepend.icn -x
Hello, world

Another take on it, using String Scanning:

<lang unicon>procedure main()

  (s := ", world") ?:= "Hello" || tab(0)
  write(s)

end</lang>

Output:

prompt$ unicon -s prepend.icn -x
Hello, world

J

<lang j> s=: 'value'

value

  s=: 'new ',s
  s

new value</lang>

Java

<lang java>// prepend public class Prepend {

   public static void main(String[] args) {
       StringBuilder sb = new StringBuilder("world");
       sb.insert(0, "Hello, ");
       System.out.println(sb);
   }

}</lang>

Output:

prompt$ javac Prepend.java
prompt$ java Prepend
Hello, world

JavaScript

<lang javascript>// No built-in prepend var s=", World" s = "Hello" + s print(s);</lang>

jq

<lang jq>"world!" as $s | "Hello " + $s</lang>

Julia

<lang julia>s = "world!" s = "Hello " * s</lang>

K

   s: "world!"

"world!"

   "Hello " , s

"Hello world!" </lang>

Kotlin

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

   var s = "Obama"
   s = "Barack " + s
   println(s)

   // It's also possible to use this standard library function
   // though this is not what it's really intended for
   var t = "Trump"
   t = t.prependIndent("Donald ")
   println(t)

}</lang>

Output:

Barack Obama
Donald Trump

Lambdatalk

<lang Scheme> {def str World} -> str

Hello, {str} -> Hello, World </lang>

Lasso

<lang Lasso>local(x = ', World!')

x->merge(1,'Hello')
x // Hello, World!</lang>

LFE

Using the concatenation operator:

<lang lisp> > (set s "world") "world" > (++ "hello " s) "hello world" </lang>

Using the concatenation function:

<lang lisp> > (set s "world") "world" > (string:concat "hello " s) "hello world" </lang>

Lingo

<lang lingo>str = "world!" put "Hello " before str put str -- "Hello world!"</lang>

LiveCode

The idiomatic way is to use "before"<lang LiveCode>put "world" into x put "hello" before x put x // hello world</lang>

Lua

By concatenation:

<lang lua> s = "12345678" s = "0" .. s print(s)</lang>

By string formatting:

<lang lua> s = "12345678" s = string.format("%s%s", "0", s) print(s)</lang>

By list joining:

<lang lua> s = "12345678" s = table.concat({"0", s}) print(s)</lang>

Output:

of each solution

012345678

M2000 Interpreter

<lang M2000 Interpreter> Module PrependString {

     A$="Hello"
     A$+=" World"
     Print A$

} PrependString </lang>

Output:

Hello World

Maple

<lang maple>l := " World"; m := cat("Hello", l); n := "Hello"||l; o := `||`("Hello", l);</lang>

Output:

                            " World"
                         "Hello World"
                         "Hello World"
                         "Hello World"

Mathematica/Wolfram Language

<lang Mathematica>a = "any text value"; a = "another string literal" <> a (* using concatenation (no built-in prepend) *)</lang>

Output:

"another string literalany text value"

Mercury

<lang mercury>:- module string_prepend.

- interface.

- import_module io.

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

- implementation.

- import_module string.

main(!IO) :-

   S = "World!\n",
   io.write_string("Hello " ++ S, !IO).</lang>

Output:

Hello World!

Nanoquery

Nanoquery has no idiomatic way to prepend one string to another. <lang Nanoquery>s1 = " a test" s1 = "this is" + s1

println s1</lang>

Output:

this is a test

Neko

The plus operator, +, concatenates string data. Neko treats strings as mutable fixed length buffers, so some care would need to be taken when prepending variables to variables as there may be buffer sizing to take into consideration. For literals, this is not a concern, as the literals are placed in buffers of the proper size by the compiler.

<lang ActionScript>/**

<doc>

String prepend in Neko</doc>

- /

var str = ", world" str = "Hello" + str $print(str, "\n")</lang>

Output:

prompt$ nekoc string-prepend.neko
prompt$ neko string-prepend.n
Hello, world

NetRexx

<lang NetRexx>s_ = 'world!' s_ = 'Hello, 's_ say s_</lang>

Output:

Hello, world!

NewLISP

<lang NewLISP>(setq str "bar") (push "foo" str) (println str)</lang>

Nim

<lang nim># Direct way. var str1, str2 = "12345678" str1 = "0" & str1 echo str1

Using "insert".

str2.insert("0") echo str2 </lang>

Output:

012345678
012345678

Objeck

<lang objeck>class Prepend {

 function : Main(args : String[]) ~ Nil {
   s := "world!";
   "Hello {$s}"->PrintLine();
 }

}</lang>

Hello World!

OCaml

<lang ocaml>let () =

 let s = ", world" in
 let s = "Hello" ^ s in
 print_endline s</lang>

Oforth

<lang Oforth>" World" "Hello" swap + println</lang>

Output:

Hello World

PARI/GP

Not supported in GP. <lang parigp>s = "world!"; s = Str("Hello, ", s)</lang>

Output:

%1 = "Hello, world!"

Pascal

Works with: Free Pascal version 2.6.2

<lang Pascal>program StringPrepend; {$mode objfpc}{$H+}

uses

 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };

var

 s: String = ' World !';

begin

 s := 'Hello' + s;
 WriteLn(S);
 ReadLn;

end.</lang>

Output:

Hello  World !

Perl

<lang Perl>use strict; use warnings; use feature ':all';

explicit concatentation

$_ = 'bar'; $_ = 'Foo' . $_; say;

lvalue substr

$_ = 'bar'; substr $_, 0, 0, 'Foo'; say;

interpolation as concatenation
(NOT safe if concatenate sigils)

$_ = 'bar'; $_ = "Foo$_"; say;</lang>

Output:

Foobar
Foobar
Foobar

Phix

Library: Phix/basics

string s = "World"
s = "Hello "&s

NB: s = prepend(s,"Hello ") gives typecheck: s is {"Hello ",87'W',111'o',114'r',108'l',100'd'}, of length 6, rather than the "Hello World" of length 11 you probably wanted.
- and likewise s = prepend("Hello ",s) is not only the wrong way round but dies with typecheck: s is {"World",72'H',101'e',108'l',108'l',111'o',32' '} (length 7).

PicoLisp

<lang picolisp>(setq Str1 "12345678!") (setq Str1 (pack "0" Str1)) (println Str1)</lang>

Output:

"012345678!"

PL/I

<lang PL/I> Pre_Cat: procedure options (main); /* 2 November 2013 */

  declare s character (100) varying;
  s = ' bowl';
  s = 'dust' || s;
  put (s);

end Pre_Cat; </lang>

dust bowl

Plain $T e X$

<lang tex>\def\prepend#1#2{% #1=string #2=macro containing a string \def\tempstring{#1}% \expandafter\expandafter\expandafter \def\expandafter\expandafter\expandafter #2\expandafter\expandafter\expandafter {\expandafter\tempstring#2}% } \def\mystring{world!} \prepend{Hello }\mystring Result : \mystring \bye</lang>

Here is an equivalent code with eTeX capabilities: <lang tex>\def\prepend#1#2{% #1=string #2=macro containing a string \edef#2{\unexpanded{#1}\unexpanded\expandafter{#2}}% } \def\mystring{world!} \prepend{Hello }\mystring Result : \mystring \bye</lang>

PowerShell

<lang PowerShell> $str = "World!" $str = "Hello, " + $str $str </lang>

Hello, World!

Prolog

Works with: SWI-Prolog

In its admirable wisdom, Prolog is generally unfriendly to state mutations and destructive assignment. However, it is also very flexible. Using the traditional representation of strings as lists of character codes, and the non-logical predicate `setarg/3`, we can destructively set the head and tail of the list to achieve a mutation of the variable holding the string. I define an operator for the purpose:

- op(200, xfx, user:(=+)).

%% +Prepend =+ +Chars % % Will destructively update Chars % So that Chars = Prepend prefixed to Chars. % eazar001 in ##prolog helped refine this approach.

[X|Xs] =+ Chars :-

 append(Xs, Chars, Rest),
 nb_setarg(2, Chars, Rest),
 nb_setarg(1, Chars, X).

</lang>

Example of this abomination in action:

<lang prolog> ?- Str = `World!`, `Hello, ` =+ Str. Str = "Hello, World!".</lang>

Note: I can't imagine when I would want to do this in Prolog.

PureBasic

<lang purebasic>S$ = " World!" S$ = "Hello" + S$ If OpenConsole()

 PrintN(S$)

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

EndIf</lang>

Output:

Hello World!

Python

File: string_prepend.py

<lang python>#!/usr/bin/env python

-*- coding: utf-8 -*-

s = "12345678" s = "0" + s # by concatenation print(s)</lang>

Output:

012345678

QB64

<lang qbasic>s$ = "prepend" s$ = "String " + s$ Print s$</lang>

Output:

String prepend

Quackery

<lang Quackery>$ "with a rubber duck." $ "One is never alone " swap join echo$</Lang>

Output:

One is never alone with a rubber duck.

Racket

<lang racket>;there is no built-in way to set! prepend in racket (define str "foo") (set! str (string-append "bar " str)) (displayln str)

but you can create a quick macro to solve that problem

(define-syntax-rule (set-prepend! str value)

 (set! str (string-append value str)))

(define macrostr " bar") (set-prepend! macrostr "foo") (displayln macrostr) </lang>

Output:

bar foo
foo bar

Raku

(formerly Perl 6) <lang perl6># explicit concatentation $_ = 'byte'; $_ = 'kilo' ~ $_; .say;

interpolation as concatenation

$_ = 'buck'; $_ = "mega$_"; .say;

lvalue substr

$_ = 'bit'; substr-rw($_,0,0) = 'nano'; .say;

regex substitution

$_ = 'fortnight'; s[^] = 'micro'; .say;

reversed append assignment

$_ = 'cooper'; $_ [R~]= 'mini'; .say;</lang>

Output:

kilobyte
megabuck
nanobit
microfortnight
minicooper

Red

<lang Red>Red [] s: "world" insert s "hello " print s </lang>

Output:

hello world

REXX

<lang rexx>zz= 'llo world!' /*─────────────── using literal abuttal.────────────*/ zz= 'he'zz /*This won't work if the variable name is X or B */ say zz

gg = "llo world!" /*─────────────── using literal concatenation.──────*/ gg = 'he' || gg say gg

aString= 'llo world!' /*─────────────── using variable concatenation.─────*/ bString= "he" aString= bString || aString say aString</lang> output

hello world!
hello world!
hello world!

Ring

<lang ring> aString = "World!" bString = "Hello, " + aString see bString + nl </lang>

Ruby

There is a method for prepending a string, aptly named "prepend". <lang ruby>str = "llo world" str.prepend("He") p str #=> "Hello world"</lang>

Rust

<lang rust> let mut s = "World".to_string(); s.insert_str(0, "Hello "); println!("{}", s); </lang>

Scala

Evaluation in Scala worksheet <lang scala> val s = "World" // Immutables are recommended //> s : String = World

 val f2 = () => ", " //Function assigned to variable
                                                 //> f2  : () => String = <function0>
 val s1 = "Hello" + f2() + s                     //> s1  : String = Hello, World
 println(s1);                                    //> Hello, World</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 local
   var string: s is "world!";
 begin
   s := "Hello " & s; 
   writeln(s);
 end func;</lang>

Output:

Hello world!

Sidef

or <lang ruby>var str = 'llo!'; str.prepend!('He'); say str;</lang>

Output:

Hello!

SNOBOL4

<lang SNOBOL4> s = ', World!'

   OUTPUT = s = 'Hello' s

END</lang>

Output:

Hello, World!

Standard ML

<lang> > val s="any text" ; val s = "any text": string > "prepended " ^ s; val it = "prepended any text": string </lang>

Stata

<lang stata>sca s="Vita Brevis" sca s="Ars Longa "+s di s

Ars Longa Vita Brevis</lang>

Swift

<lang Swift>var str = ", World" str = "Hello \(str)" println(str)</lang>

Output:

Hello, World!

Tcl

Concatenation is a fundamental feature of Tcl's basic language syntax. <lang tcl>set s "llo world" set s "he$s" puts $s</lang>

Output:

hello world

Ursa

<lang ursa>decl string s

set s to "world"

set s "world"

prepend "hello "

set s (+ "hello " s)

outputs "hello world"

out s endl console</lang>

VBA

<lang VB>Function StringPrepend() Dim s As String s = "bar" s = "foo" & s Debug.Print s End Function</lang>

VBScript

<lang vb>s = "bar" s = "foo" & s WScript.Echo s</lang>

Output:

foobar

Wart

Wren

<lang javascript>var s = "world!" s = "Hello, " + s System.print(s)</lang>

Output:

Hello, world!

Xojo

<lang vb>Dim s As String = "bar" s = "foo" + s MsgBox(s)</lang>

Output:

foobar

zkl

<lang zkl>s:="bar"; s="foo" + s; s.println(); s:="bar"; s=String("foo",s); s.println(); s:="bar"; s="%s%s".fmt("foo",s); s.println();

  // a Data is a byte buffer/editor:

s:=Data(Void,"bar").insert(0,"foo").text; s.println();</lang>

Output:

foobar
foobar
foobar
foobar