String prepend: Difference between revisions

{{trans|Python}}

 

s = ‘0’s

 

{{out}}

 

=={{header|360 Assembly}}==

PREPEND CSECT

USING PREPEND,13 base register

B DC C'Hello ' b

C DC CL80' ' c

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program appendstr64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

 

=={{header|Action!}}==

BYTE POINTER srcPtr,dstPtr

BYTE len

TestPrepend(text,"World!")

TestPrepend(text,"Hello ")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/String_prepend.png Screenshot from Atari 8-bit computer]

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.

 

 

procedure Prepend_String is

S := "Hello " & S;-- this is the operation to prepend "Hello " to S.

Ada.Text_IO.Put_Line(To_String(S));

 

{{out}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.7 algol68g-2.7].}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards).}}

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

 

STRING str := "12345678";

"0" +=: str;

{{out}}

<pre>

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:

 

set aVariable to "Hello " & aVariable

 

{{output}}

 

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:

 

use framework "Foundation"

 

set aVariable to aVariable's stringByReplacingOccurrencesOfString:("^") withString:("Hello ") ¬

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

 

But there's also an NS''Mutable''String class. This has 'replace' versions of the 'stringByReplacing' methods above and also this <tt>insertString:atIndex:</tt> method:

 

use framework "Foundation"

 

set aVariable to current application's class "NSMutableString"'s stringWithString:("world!")

tell aVariable to insertString:("Hello ") atIndex:(0)

 

{{output}}

 

=={{header|Arturo}}==

a: "Hello" ++ a

print a

 

d: "World"

 

{{out}}

 

=={{header|Asymptote}}==

write("Hello" + s1);

write("Hello", s1);

string s2 = "Hello" + s1;

 

=={{header|AutoHotkey}}==

s := s "bar"

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f STRING_PREPEND.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|BaCon}}==

s$ = "String " & s$

 

{{out}}

 

=={{header|BASIC}}==

S$ = "Hello" + S$

PRINT S$

{{out}}

<pre>Hello World!</pre>

 

==={{header|Applesoft BASIC}}===

110 LET S$="Hello"+S$

 

==={{header|BASIC256}}===

a$ = "Hello"; a$

print a$

a$ = "Hello" + a$

# and

 

==={{header|IS-BASIC}}===

110 LET S$="Hello"&S$

 

==={{header|Run BASIC}}===

{{works with|QBasic}}

{{works with|Yabasic}}

a$ = "Hello" + a$

print a$

 

' en RB, LB and BASIC256 would also be valid

 

==={{header|True BASIC}}===

{{works with|BASIC256}}

LET a$ = "Hello" & a$

PRINT a$

 

==={{header|Yabasic}}===

{{works with|QBasic}}

{{works with|Run BASIC}}

a$ = "Hello" + a$

 

=={{header|Bracmat}}==

& str$("Hello " !string):?string

<pre>Hello World!</pre>

 

=={{header|C}}==

#include<string.h>

#include<stdlib.h>

printf("%s\n",str);

return 0;

{{out}}

<pre>Changed my String</pre>

 

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

 

namespace PrependString

}

}

<pre>Hello World</pre>

 

=={{header|C++}}==

#include <algorithm>

#include <string>

std::cout << prepended << std::endl ;

return 0 ;

{{out}}

<pre>prepended tomy string</pre>

 

===A pure function implementation with immutability ===

(defn str-prepend [a-string, to-prepend]

(str to-prepend a-string))

 

=== REPL demonstrations with mutability in mind ===

a) with the atom data structure

 

(def s (atom "World"))

(swap! s #(str "Hello, " %))

user=> @s

user=> "Hello, Wolrd"

 

b) with the ref data structure

(def s (ref "World"))

(dosync (alter s #(str "Hello " %)))

user=> @s

user=> "Hello World"

 

=={{header|COBOL}}==

program-id. prepend.

data division.

move function reverse (str (1:len)) to str

.

<pre>Hello World!</pre>

{{works with|GNU Cobol|2.0}}

PROGRAM-ID. prepend.

 

DISPLAY str

.

 

=={{header|ColdFusion}}==

=== Classic tag based CFML ===

<cfoutput>

<cfset who = "World!">

#"Hello " & who#

</cfoutput>

{{Output}}

<pre>

 

=== Script Based CFML ===

who = "World!";

greeting = "Hello " & who;

writeOutput( greeting );

{{Output}}

<pre>

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

A macro is necessary in order to prepend a string in-place:

"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")

{{out}}

<pre>barfoo</pre>

 

=={{header|D}}==

 

void main() {

s = "Hello " ~ s;

writeln(s);

{{out}}

<pre>Hello world!</pre>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program String_preappend;

 

writeln(h);

readln;

{{out}}

<pre>Hello World

=={{header|Dyalect}}==

 

s = "Hello " + s

 

=={{header|Déjà Vu}}==

set :s concat( "Hello " s)

{{out}}

<pre>Hello world!</pre>

 

=={{header|EchoLisp}}==

define-syntax-rule

(set!-string-prepend a before)

name

→ "Elvis Presley"

 

=={{header|Elena}}==

import extensions'text;

var s := "World";

s := "Hello " + s;

// Alternative way

var s2 := StringWriter.load("World");

s2.insert(0, "Hello ");

console.readChar()

 

=={{header|Elixir}}==

str1 = "World!"

str = "Hello, " <> str1

 

{{out}}

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

 

(setq str (concat "foo" str))

 

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

 

{{libheader|cl-lib}}

 

(defvar str "bar")

(cl-callf2 concat "foo" str)

 

Buffers can be thought of as expandable strings:

 

(with-current-buffer buf

(insert "bar"))

(insert "foo")

(buffer-string)))

 

=={{header|Erlang}}==

 

=={{header|ERRE}}==

......

S$=" World!"

PRINT(S$)

......

{{out}}

<pre>Hello World!</pre>

 

=={{header|F Sharp|F#}}==

s <- "Hello, " + s

 

=={{header|Factor}}==

"world"

"Hello " prepend

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach not sure if it's the most falconic way'''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

s = s + "Falcon"

> s

{{out}}

<pre>

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.

 

 

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

R> ; \ leave a copy of addr2 on the data stack

 

 

Test our language extensions interactively at the console

 

===Initial difficulty===

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

 

WRITE (6,3) (TEXT(I), I = 1,6)

3 FORMAT (66A2)

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: <code>"Wo"</code> is deemed to be <code>"Wo "</code> 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".

 

 

===Character facility===

TEXT = "World!"

TEXT = "Hello "//TEXT

WRITE (6,*) TEXT

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, <code>TEXT(1:6) = "World!"</code> 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!

 

 

=={{header|FreeBASIC}}==

 

Var s = "prepend"

s = "String " + s

Print s

 

{{out}}

Free Pascal supports everything shown in [[#Pascal|§ Pascal]] (except the <tt>string</tt> schema data type, <tt>string(20)</tt> must be written like here).

Furthermore, using the compiler directive <tt>{$COperators}</tt> the following is possible, too:

line: string[20];

begin

line += 'world!';

writeLn(line)

 

=={{header|Gambas}}==

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

Dim sString1 As String = "world!"

Dim sString2 As String = "Hello "

Print sString1

 

Output:

<pre>

 

=={{header|Go}}==

 

=={{header|Haskell}}==

Prelude> let f = (++" World!")

Prelude> f "Hello"

 

{{out}}

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

 

 

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

 

s := ", world"

s[1:1] ||:= "Hello"

write(s)

 

{{out}}

Another take on it, using String Scanning:

 

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

write(s)

 

{{out}}

 

=={{header|J}}==

s

value

s=: 'new ',s

s

 

=={{header|Java}}==

 

=={{header|Javascript}}==

var s=", World"

s = "Hello" + s

 

=={{header|jq}}==

 

=={{header|Julia}}==

 

=={{header|K}}==

s: "world!"

"world!"

"Hello " , s

"Hello world!"

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

t = t.prependIndent("Donald ")

println(t)

 

{{out}}

 

=={{header|Lambdatalk}}==

{def str World}

-> str

Hello, {str}

-> Hello, World

 

=={{header|Lasso}}==

#x->merge(1,'Hello')

 

=={{header|LFE}}==

Using the concatenation operator:

 

> (set s "world")

"world"

> (++ "hello " s)

"hello world"

 

Using the concatenation function:

 

> (set s "world")

"world"

> (string:concat "hello " s)

"hello world"

 

=={{header|Lingo}}==

put "Hello " before str

put str

 

=={{header|LiveCode}}==

put "hello" before x

 

=={{header|Lua}}==

By concatenation:

 

s = "12345678"

s = "0" .. s

 

By string formatting:

 

s = "12345678"

s = string.format("%s%s", "0", s)

 

By list joining:

 

s = "12345678"

s = table.concat({"0", s})

 

{{out}} of each solution:

 

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

Module PrependString {

A$="Hello"

}

PrependString

 

{{out}}

 

=={{header|Maple}}==

m := cat("Hello", l);

n := "Hello"||l;

{{out}}

<pre>

 

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

{{out}}

<pre>"another string literalany text value"</pre>

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

main(!IO) :-

S = "World!\n",

{{out}}

<pre>

=={{header|Nanoquery}}==

Nanoquery has no idiomatic way to prepend one string to another.

s1 = "this is" + s1

 

 

{{out}}

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.

 

<doc><p>String prepend in Neko</pre></doc>

**/

var str = ", world"

str = "Hello" + str

{{out}}

<pre>prompt$ nekoc string-prepend.neko

 

=={{header|NetRexx}}==

s_ = 'Hello, 's_

{{out}}

<pre>

 

=={{header|NewLISP}}==

(push "foo" str)

 

=={{header|Nim}}==

var str1, str2 = "12345678"

str1 = "0" & str1

str2.insert("0")

echo str2

 

{{out}}

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

s := "world!";

"Hello {$s}"->PrintLine();

}

 

<pre>

 

=={{header|OCaml}}==

let s = ", world" in

let s = "Hello" ^ s in

 

=={{header|Oforth}}==

 

 

{{out}}

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

Not supported in GP.

{{out}}

<pre>%1 = "Hello, world!"</pre>

{{works with|Extended Pascal}}

 

var

line: string(20);

writeStr(line, line, 'world!');

writeLn(line)

{{out}}

<pre>Hello world!

 

=={{header|Perl}}==

use warnings;

use feature ':all';

$_ = 'bar';

$_ = "Foo$_";

 

{{out}}

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"World"</span>

<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Hello "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s</span>

<b>NB:</b> 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.<br>

&nbsp;&nbsp; &nbsp; &nbsp; - 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).

 

=={{header|Picat}}==

As usual there are a couple ways of doing this. The most common is probable to use string concatenation (<code>++</code>), but <code>append/3</code> might be useful if backtracking is needed.

S = "123456789",

S := insert_all(S,1,"DE"),

println(S),

 

{{out}}

 

=={{header|PicoLisp}}==

(setq Str1 (pack "0" Str1))

{{out}}

<pre>

 

=={{header|PL/I}}==

Pre_Cat: procedure options (main); /* 2 November 2013 */

declare s character (100) varying;

put (s);

end Pre_Cat;

<pre>

dust bowl

 

=={{header|PlainTeX}}==

\def\tempstring{#1}%

\expandafter\expandafter\expandafter

\prepend{Hello }\mystring

Result : \mystring

 

Here is an equivalent code with eTeX capabilities:

\edef#2{\unexpanded{#1}\unexpanded\expandafter{#2}}%

}

\prepend{Hello }\mystring

Result : \mystring

 

=={{header|PowerShell}}==

$str = "World!"

$str = "Hello, " + $str

$str

<pre>Hello, World!</pre>

 

the string. I define an operator for the purpose:

 

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

 

nb_setarg(2, Chars, Rest),

nb_setarg(1, Chars, X).

 

Example of this abomination in action:

 

?- Str = `World!`, `Hello, ` =+ Str.

 

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

 

=={{header|PureBasic}}==

S$ = "Hello" + S$

If OpenConsole()

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

CloseConsole()

{{out}}

<pre>Hello World!</pre>

'''File: string_prepend.py'''

 

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

 

s = "12345678"

s = "0" + s # by concatenation

 

{{out}}

 

=={{header|QB64}}==

s$ = "String " + s$

{{out}}

<pre>String prepend</pre>

=={{header|Quackery}}==

 

$ "One is never alone "

swap join

 

{{out}}

 

=={{header|Racket}}==

(define str "foo")

(set! str (string-append "bar " str))

(set-prepend! macrostr "foo")

(displayln macrostr)

{{out}}

<pre>bar foo

=={{header|Raku}}==

(formerly Perl 6)

$_ = 'byte';

$_ = 'kilo' ~ $_;

$_ = 'cooper';

$_ [R~]= 'mini';

{{out}}

<pre>kilobyte

 

=={{header|Red}}==

s: "world"

insert s "hello "

print s

{{out}}

<pre>hello world</pre>

 

=={{header|REXX}}==

zz= 'he'zz /*This won't work if the variable name is X or B */

say zz

bString= "he"

aString= bString || aString

'''output'''

<pre>

 

=={{header|Ring}}==

aString = "World!"

bString = "Hello, " + aString

see bString + nl

 

=={{header|Ruby}}==

There is a method for prepending a string, aptly named "prepend".

str.prepend("He")

 

=={{header|Rust}}==

let mut s = "World".to_string();

s.insert_str(0, "Hello ");

println!("{}", s);

 

=={{header|Scala}}==

Evaluation in Scala worksheet

val f2 = () => ", " //Function assigned to variable

//> f2 : () => String = <function0>

val s1 = "Hello" + f2() + s //> s1 : String = Hello, World

 

=={{header|Seed7}}==

 

const proc: main is func

s := "Hello " & s;

writeln(s);

 

{{out}}

 

=={{header|Sidef}}==

str.sub!(/^/, 'He');

 

or

str.prepend!('He');

 

{{out}}

 

=={{header|SNOBOL4}}==

OUTPUT = s = 'Hello' s

{{out}}

<pre>

Hello, World!

</pre>

 

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

> val s="any text" ;

val s = "any text": string

> "prepended " ^ s;

val it = "prepended any text": string

 

=={{header|Stata}}==

sca s="Ars Longa "+s

di s

 

 

=={{header|Swift}}==

str = "Hello \(str)"

{{out}}

<pre>

=={{header|Tcl}}==

Concatenation is a fundamental feature of Tcl's basic language syntax.

set s "he$s"

{{out}}

<pre>hello world</pre>

 

=={{header|Ursa}}==

 

# set s to "world"

 

# outputs "hello world"

 

=={{header|VBA}}==

Dim s As String

s = "bar"

s = "foo" & s

Debug.Print s

 

=={{header|VBScript}}==

s = "foo" & s

{{Out}}

<pre>foobar</pre>

 

s = "Hello, " + s

 

{{out}}

 

=={{header|Wart}}==

 

=={{header|Wren}}==

s = "Hello, " + s

 

{{out}}

 

=={{header|Xojo}}==

s = "foo" + s

{{Out}}

<pre>foobar</pre>

 

=={{header|XPL0}}==

char S, T(80);

[S:= "world!";

S:= StrCat(StrCopy(T,"Hello, "), S);

Text(0, S);

 

{{out}}

 

=={{header|zkl}}==

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:

{{out}}

<pre>