String prepend: Difference between revisions

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

<br><br>

=={{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>

British Museum.

The rosetta stone is at British Museum.

</pre>

 

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>

012345678

</pre>

 

=={{header|AutoHotkey}}==

s := s "bar"

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f STRING_PREPEND.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

foobar

</pre>

 

=={{header|BASIC}}==

S$ = "Hello" + S$

PRINT S$

{{out}}

<pre>Hello World!</pre>

 

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

110 LET S$="Hello"+S$

 

 

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

110 LET S$="Hello"&S$

 

=={{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|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}}

 

=={{header|Emacs Lisp}}==

<pre>

</pre>

 

 

=={{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}}

<pre>

String prepend

</pre>

 

=={{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}}

Donald Trump

</pre>

 

=={{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>

</pre>

 

{{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}}==

 

=={{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>

 

=={{header|Pascal}}==

 

var

begin

{{out}}

 

=={{header|Perl}}==

use warnings;

use feature ':all';

$_ = 'bar';

$_ = "Foo$_";

 

{{out}}

 

=={{header|Phix}}==

 

=={{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}}

012345678

</pre>

 

=={{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>

 

=={{header|Wart}}==

 

=={{header|Xojo}}==

s = "foo" + s

{{Out}}

<pre>foobar</pre>

 

=={{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>