String interpolation (included): Difference between revisions

 

=={{header|11l}}==

print(‘Mary had a ’extra‘ lamb.’)

print(‘Mary had a #. lamb.’.format(extra))

 

{{out}}

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program insertString64.s */

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

.include "../includeARM64.inc"

 

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

CHAR ARRAY extra="little"

 

PrintF("Mary had a %S lamb.%E",extra)

{{out}}

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

 

=={{header|Ada}}==

use Ada.Strings, Ada.Text_IO;

procedure String_Replace is

Put_Line (Fixed.Replace_Slice (

Original, Index, Index + Tbr'Length - 1, New_Str));

 

Alternatively

 

 

=={{header|Aikido}}==

printf ("Mary had a %s lamb\n", little)

 

// alternatively

 

=={{header|ALGOL 68}}==

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - requires formatted transput}}

'''string'''s are simply '''flex''' arrays of '''char'''. '''format'''s on the other hand take on some of the properties of '''proc'''edures including the scoping rules.

# as a STRING #

STRING extra = "little";

# or: use simply use STRING concatenation #

print(("Mary had a "+extra+" lamb.", new line))

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program insertString.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

 

=={{header|APL}}==

s ← 'Mary had a ∆ lamb' ⋄ s[s⍳'∆'] ← ⊂'little' ⋄ s ← ∊s

s

'Mary had a ∆ lamb, its fleece was ∆ as ∆.' sInterp 'little' 'large' 42

Mary had a little lamb, its fleece was large as 42.

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|Asymptote}}==

write("Mary had a " + s1 + " lamb");

s1 = "little";

 

=={{header|AutoHotkey}}==

LIT = little

string = Mary had a %LIT% lamb.

string := "Mary had a" LIT " lamb."

 

 

Documentation: [http://www.autohotkey.com/docs/Variables.htm#Variables Variables] (see '''Storing values in variables''' and '''Retrieving the contents of variables''')

=={{header|AWK}}==

String interpolation is usually done with functions sub() and gsub(). gawk has also gensub().

BEGIN {

str="Mary had a # lamb."

gsub(/#/, "little", str)

print str

 

=={{header|BASIC}}==

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

print "Mary had a "; x$; " lamb"

 

x$ = "little"

 

==={{header|QBasic}}===

PRINT "Mary had a "; x$; " lamb"

x$ = "little"

PRINT USING "Mary also had a & lamb"; x$

' this code above doesn't modify the first string subsustituting a piece of it with another string

 

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

PRINT "Mary had a "; x$; " lamb"

 

LET outstring$ = USING$("$#####", x$)

PRINT "Mary also had a "; outstring$; " lamb"

 

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

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

call :interpolate %1 %2 res

set str=%~2

set %3=!pat:X=%str%!

 

''Demo''

 

=={{header|BQN}}==

Here, the symbol for Nothing(`·`) is used as a replacement character.

 

_interpolate ← {∾(•Fmt⍟(¬Str)¨𝕨)⌾((𝕗=𝕩)⊸/)𝕩}

 

 

=={{header|Bracmat}}==

Use pattern matching to find the part of the string up to and the part of the string following the magic X. Concatenate these parts with the string "little" in the middle.

 

 

=={{header|C}}==

Include the <code><stdio.h></code> header to use the functions of the [[wp:Printf|printf]] family:

 

int main() {

printf("Mary had a %s lamb.\n", extra);

return 0;

 

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

This is called [http://msdn.microsoft.com/en-us/library/txafckwd.aspx "composite formatting"] in MSDN.

 

{

static void Main()

System.Console.WriteLine(formatted);

}

 

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

#include <iostream>

 

std::cout << "String after replacement: " << newString << " \n" ;

return 0 ;

{{works with|C++11}}

 

#include <string>

 

return out;

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. interpolation-included.

 

 

GOBACK

 

=={{header|Coco}}==

As CoffeeScript, but [https://github.com/satyr/coco/wiki/additions#wiki-variable-interpolation-x the braces are optional if the expression to be interpolated is just a variable]:

 

 

=={{header|CoffeeScript}}==

size = 'little'

console.log "Mary had a #{size} lamb." # Mary had a little lamb.

Multi-line strings and arbtrary expressions work: #{ 5 * 4 }

"""

 

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

 

More documentation on the [http://www.cs.cmu.edu/Groups/AI/html/hyperspec/HyperSpec/Body/fun_format.html FORMAT] function.

 

=={{header|D}}==

import std.stdio, std.string;

 

"Mary had a %s lamb.".format("little").writeln;

"Mary had a %2$s %1$s lamb.".format("little", "white").writeln;

{{out}}

<pre>Mary had a little lamb.

 

=={{header|Delphi}}==

 

uses

writeln(Output);

 

{{out}}

<pre>Mary had a little lamb.

 

=={{header|DWScript}}==

{{out}}

<pre>Mary had a little lamb.</pre>

Dyalect has a built-in [https://github.com/vorov2/dyalect/wiki/String#interpolation string interpolation] feature.

 

 

=={{header|E}}==

 

 

The <code>`...`</code> syntax in general may be used as a sort of syntax extension; string interpolation is just the default case. [http://www.erights.org/elang/grammar/quasi-overview.html More information on E quasi-literals.] (Note that this documentation may be somewhat out of date.)

The above code is equivalent to (expands into):

 

 

If an identifier precedes the opening <code>`</code>, then it replaces <code>simple</code>; the quasiParser may be an arbitrary user-defined object. In this way, E provides lightweight syntax for embedding other languages: XML, JSON, GUI layouts, regular expressions, etc.

=={{header|EchoLisp}}==

'''format''' and '''printf''' use replacement directives to perform interpolation. See [http://www.echolalie.org/echolisp/help.html#format format specification] in EchoLisp documentatiuon.

;; format uses %a or ~a as replacement directive

(format "Mary had a ~a lamb" "little")

(format "Mary had a %a lamb" "little")

→ "Mary had a little lamb"

 

=={{header|ECL}}==

IMPORT STD;

STD.Str.FindReplace('Mary had a X Lamb', 'X','little');

 

=={{header|Elena}}==

ELENA 4.x :

public program()

var s := "little";

console.printLineFormatted("Mary had a {0} lamb.",s).readChar()

 

=={{header|Elixir}}==

Elixir borrows Ruby's #{...} interpolation syntax.

x = "little"

IO.puts "Mary had a #{x} lamb"

 

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

(format "Mary had a %s lamb." little)

;; message takes a format string as argument

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

sequence s

s = sprintf("Mary had a %s lamb.",{lambType})

See

[http://openeuphoria.org/docs/std_text.html#_3233_sprintf sprintf],

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

[http://msdn.microsoft.com/en-us/library/ee370560(VS.100).aspx Documentation]

 

=={{header|Factor}}==

 

SYMBOL: little

"little" little set

 

 

I tried to be as specific as possible here. The challenge says to use a ''variable'' so that is what I used. It could have been done more cleanly using a CONSTANT.

 

 

CONSTANT: little "little"

 

 

=={{header|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 */

// line 1: use of the = operator

// line 2: use of the @ and $ operator

{{out}}

<pre>

Interpolating a variable value into a string is done by using a $ prefix on the variable name within a string. For example:

 

fansh> x := "little"

little

fansh> echo ("Mary had a $x lamb")

Mary had a little lamb

 

Documentation at: [http://fantom.org/doc/docLang/Literals.html#interpolation Fantom website]

=={{header|Forth}}==

 

variable #src

variable 'out

here 'out ! ," BIG" here 'out @ - #out !

format

{{out}}

<pre>

 

=={{header|Fortran}}==

 

write (*,*) trim(inter("Mary had a X lamb.","X","little"))

end function inter

 

=={{header|FreeBASIC}}==

It is also possible to use C library functions such as printf or sprintf, which allow more conventional string interpolation,

as easily as if they were part of FB itself:

 

#Include "crt/stdio.bi" '' header needed for printf

x = "little"

printf("Mary also had a %s lamb", x)

 

{{out}}

 

=={{header|Frink}}==

 

=={{header|FunL}}==

 

=={{header|Gambas}}==

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

 

Print Subst("Mary had a &1 lamb", "little")

 

Output:

<pre>

This kind of string interpolation is indeed a strong feature in Gastona. We add one more

indirection in the sample just to ilustrate it.

 

<how> //little

<main> //Mary @<what>

{{out|Output}}

<pre>

=={{header|Go}}==

Doc: [http://golang.org/pkg/fmt/ http://golang.org/pkg/fmt/]

package main

 

fmt.Println(out)

}

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

No such facilities are defined in Haskell 98, but the <code>base</code> package distributed with GHC provides a <code>[http://hackage.haskell.org/packages/archive/base/latest/doc/html/Text-Printf.html#v:printf printf]</code> function.

 

 

 

=={{header|Haxe}}==

{{trans|C#}}

static function main() {

var extra = 'little';

Sys.println(formatted);

}

 

{{out}}

=={{header|HicEst}}==

[http://www.HicEst.com/EDIT Further documentation on HicEst string interpolation function EDIT()]

 

output_string = original

 

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

Icon and Unicon are descended from a line of languages with a wealth of string manipulation capabilities. [http://www.cs.arizona.edu/icon/ftp/doc/lb1up.pdf See The Icon Programming Language, 3rd Edition; Griswold and Griswold; Chapter 3 String Scanning]

s3 := "little"

s1 := "Mary had a humongous lamb."

s1 ?:= tab(find(s2)) || (=s2,s3) || tab(0) # replaces the first instance of s2 with s3

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/strings.icn Note the strings library includes convenient procedures for string replacement] such as replace(s1,s2,s3) which replaces all occurrences of s2 in s1 with s3 and replacem(s1,s2,s3,...) which replaces multiple pairs.

=={{header|J}}==

The <code>strings</code> and <code>printf</code> scripts are part of the base library.

'Mary had a %s lamb.' sprintf <'little'

Mary had a little lamb.

Mary had a little lamb.

'Mary had a %s lamb.' rplc '%s';'little'

 

Documentation:

The comments in these library files give brief descriptions of their contents, and you can browse them using open:

 

 

Alternatively, both [http://www.jsoftware.com/docs/help602/user/script_strings.htm strings] and [http://www.jsoftware.com/help/jforc/input_and_output.htm#_Toc191734427 printf] have various web pages describing them, and printf has a lab demonstrating its use (from J's IDE's menu, go Studio -> Labs... and then look in the System category).

 

=={{header|Java}}==

String little = "little";

String replaced = original.replace("X", little); //does not change the original String

//Alternative:

String formatted = String.format("Mary had a %s lamb.", little);

 

=={{header|JavaScript}}==

var little = "little";

 

Or,

 

var X = "little";

 

=={{header|jq}}==

 

'''Documentation''': [http://stedolan.github.io/jq/manual/#Stringinterpolationfoo String interpolation]

 

=={{header|Julia}}==

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

// it must be treated as an expression

println("Mary had a ${s}r lamb") // not $sr

 

{{out}}

 

=={{header|Lambdatalk}}==

{def original Mary had a X lamb}

-> original

{S.replace X by {Y} in {original}}

-> Mary had a little lamb

 

=={{header|Lasso}}==

Lasso doesn't really have built-in string interpolation, but you can use the built-in email mail-merge capability:

{{out}}

<pre>Mary had a little lamb</pre>

=={{header|LiveCode}}==

Livecode has a [http://docs.runrev.com/Function/merge merge] function for interpolation

put merge("Mary had a [[str]] lamb.")

 

 

=={{header|Lua}}==

There is no default support for automatic interpolation of variables names being used as placeholders within a string. However, interpolation is easily emulated by using the [string.gsub] function:

 

 

or using [string.format] function like C:

str2 = ( "Mary had a %s lamb." ):format( "little" )

 

=== Literal characters ===

Interpolation of literal characters escape sequences does occur within a string:

 

 

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

module checkit {

size$="little"

}

checkit

 

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

StringReplace["Mary had a X lamb.", {"X" -> Extra}]

 

=={{header|Maxima}}==

 

=={{header|Neko}}==

<doc><h2>String interpolation, in Neko</h2>

<p><a href="https://nekovm.org/doc/view/string/">NekoVM String Library</a></p>

var sprintf = $loader.loadprim("std@sprintf", 2)

 

 

{{out}}

=={{header|Nemerle}}==

Nemerle has a few ways to accomplish this. It provides an implementation of '''printf()''', $ interpolation within the '''print()''' method, and the most general use is $ interpolation within $ quoted strings.

using System.Console;

using Nemerle.IO; // contains printf() and print()

WriteLine($"Mary had a $extra lamb.");

}

 

=={{header|NetRexx}}==

The Built In Functions (BIFs) of [[NetRexx]] can be employed to manipulate strings quite successfully but for more flexible string interpolation a function package like Java's MessageFormat should be used.

 

options replace format comments java crossref savelog symbols

 

return

{{out}}

<pre style="height: 5ex; overflow:scroll;">

Nim offers two methods to build a string with interpolation.

The first one uses the procedure <code>format</code> or the operator <code>%</code>. Note that with the procedure, an implicit conversion of the arguments is done. With the operator, the conversion must be explicit, using for instance the <code>$</code> operator.

 

var str = "little"

echo "Mary had a $# lamb".format(str)

echo "Mary had a $# lamb" % [str]

 

The second method allows to place the expressions directly in the string. There is also two forms, one using the prefix "fmt", the other using the prefix "&". The second form must be used if the string contains newline characters.

 

 

var str: string = "little"

echo fmt"Mary had a {str} lamb"

 

=={{header|OCaml}}==

The OCaml standard library provides the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Printf.html Printf]:

 

 

Another option is to use compiler plugin mechanism and [https://opam.ocaml.org/packages/ppx_string_interpolation/ ppx_string_interpolation]:

 

let extra = "little" in

[%string "Mary had a $extra lamb."]

 

=={{header|OOC}}==

In a String all expressions between #{...} will be evaluated.

main: func {

X := "little"

"Mary had a #{X} lamb" println()

}

 

=={{header|Oz}}==

String interpolation is unidiomatic in Oz. Instead, "virtual strings" are used. [http://www.mozart-oz.org/documentation/op/node4.html Virtual strings] are tuples of printable values and are supported by many library functions.

 

X = "little"

in

 

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

The Pari library has string interpolation, which extends C's:

string_interpolate(GEN n)

{

pari_printf("The value was: %Ps.\n", n);

GEN s = pari_sprintf("Storing %Ps in a string", n);

 

{{works with|PARI/GP|version 2.4.4 and above}}

GP can also interpolate strings:

 

=={{header|Perl}}==

print "Mary had a $extra lamb.\n";

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

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

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Mary had a %s lamb."</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">size</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>

{{out}}

<pre>

 

=={{header|PHP}}==

$extra = 'little';

echo "Mary had a $extra lamb.\n";

printf("Mary had a %s lamb.\n", $extra);

 

=={{header|Picat}}==

V = "little",

printf("Mary had a %w lamb\n", V),

% As a function

S = to_fstring("Mary had a %w lamb", V),

 

 

=={{header|PicoLisp}}==

 

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

sit: Proc Options(main);

/*********************************************************************

Return(res);

End;

{{out}}

<pre>

=={{header|PowerShell}}==

Using the format (-f) operator:

 

Using format string with the WriteLine static method

 

Using the format method of the string type

 

Note: numeric and date/time formats can be specified with {index:formatString} (i.e. {0:###,###})

 

=={{header|Prolog}}==

format('Mary had a ~w lamb.', [Extra]), % display result

 

Using [http://www.swi-prolog.org/pack/list?p=func library(func)] for SWI-Prolog:

 

 

Using [http://www.swi-prolog.org/pack/list?p=interpolate library(interpolate)] for SWI-Prolog:

 

 

=={{header|PureBasic}}==

The function [http://www.purebasic.com/documentation/string/replacestring.html ReplaceString()] is built-in and can have both constants and variables as parameters.

''' Implemented in a program context

Define txt$, txtvar.s="little"

 

Mary:

Data.s "Mary had a X lamb."

 

=={{header|Python}}==

 

Using the % [http://docs.python.org/library/stdtypes.html#string-formatting-operations string interpolation operator]:

>>> extra = 'little'

>>> original % extra

 

Using the [http://docs.python.org/library/string.html#string-formatting .format method of strings]:

>>> extra = 'little'

>>> original.format(**locals())

Using the format method, but replace by an expressions position as an argument to the format method call instead of by name:

>>> extra = 'little'

>>> original.format(extra)

 

Using the [http://docs.python.org/library/string.html#template-strings Template] class of the string module:

>>> original = Template('Mary had a $extra lamb.')

>>> extra = 'little'

>>> original.substitute(**locals())

 

Using the new [https://docs.python.org/3/whatsnew/3.6.html#whatsnew36-pep498 f-strings] string literal available from Python 3.6:

>>> f'Mary had a {extra} lamb.'

'Mary had a little lamb.'

=={{header|QB64}}==

DefStr S

 

Print String1, "by LEFT$ and RIGHT$"

 

 

=={{header|Racket}}==

See the documentation on [http://docs.racket-lang.org/reference/Writing.html?q=printf#%28def._%28%28quote._~23~25kernel%29._fprintf%29%29 fprintf] for more information on string interpolation in Racket.

 

#lang racket

 

(format "Mary had a ~a lamb" "little")

 

=={{header|Raku}}==

(formerly Perl 6)

say "Mary had a $extra lamb"; # variable interpolation

say "Mary had a { $extra } lamb"; # expression interpolation

say $extra.fmt("Mary had a %s lamb"); # inside-out printf

my @lambs = <Jimmy Bobby Tommy>;

 

=={{header|REBOL}}==

size: "little"

build-markup str

;REBOL3 also has the REWORD function

str: "Mary had a $size lamb"

 

=={{header|REXX}}==

<br>However, interpolation can be emulated using the &nbsp; '''changestr''' &nbsp; function:

 

/*the string to be replaced is */

replace = "little" /*usually a unique character(s) */

say 'original4 =' original4

say 'replaced4 =' new3

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>'''output'''

 

=={{header|Ring}}==

aString =substr("Mary had a X lamb.", "X", "little")

see aString + nl

 

=={{header|Ruby}}==

=> "little"

irb(main):002:0> "Mary had a #{extra} lamb."

=> "Mary had a little lamb."

irb(main):003:0> "Mary had a %s lamb." % extra

 

Documentation:

 

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

a$ = word$(a$,1,"X")+"little"+word$(a$,2,"X")

print a$

 

=={{header|Rust}}==

Rust has very powerful string interpolation. [https://doc.rust-lang.org/beta/std/fmt/ Documentation here.]

println!("Mary had a {} lamb", "little");

// You can specify order

// Or named arguments if you prefer

println!("{name} had a {adj} lamb", adj="little", name="Mary");

 

=={{header|Scala}}==

{{libheader|Scala}}

 

 

import util.matching.Regex._

println("Split : " + "Mary had a ${x} lamb.".split("""\$\{([^}]+)\}""").mkString(size))

}

Documentation:

* Scala 2.10.0: [http://docs.scala-lang.org/overviews/core/string-interpolation.html string interpolation]

 

=={{header|Sed}}==

# Usage example: . interpolate "Mary has a X lamb" "quite annoying"

 

=={{header|Seed7}}==

 

const proc: main is func

replaced := replace(original, "X", little);

writeln(replaced);

 

{{out}}

=={{header|SenseTalk}}==

SenseTalk does string interpolation through the <code>merge</code> function, which can evaluate any sort of embedded expression, including entire sections of code like conditionals or repeat loops. For convenience, the merge function can be invoked by simply using a <code>!</code> before a string literal (this is needed because string literals are actually literal in SenseTalk -- there are no characters with hidden meaning by default).

 

put "Mary had a [[x]] lamb." -- this is a literal string

put !"[[repeat with n=2 to 6]]Mary had [[n]] [[x]] lambs.[[return]][[end repeat]]"

put !"Mary had [[repeat with n=2 to 6]][[n]] [[x]] [[end repeat]]lambs."

{{out}}

<pre>

 

=={{header|Sidef}}==

 

or:

 

See: [https://github.com/trizen/sidef/wiki#strings documentation]

=={{header|SNOBOL4}}==

Every statement in SNOBOL can is a subset of pattern replacement having a subject (s1 in this case), object (s2), and replacement (s3).

s2 = "humongous"

s3 = "little"

s1 s2 = s3

See [ftp://ftp.cs.arizona.edu/snobol/gb.pdf The SNOBOL4 Programming Language; Griswold, Poage, Polonsky; Chapter 2 Pattern Matching]

 

See '''[https://www.stata.com/help.cgi?mf_printf printf]''' in Stata help.

 

 

=={{header|Swift}}==

 

=={{header|Tailspin}}==

String interpolation is the normal way to create strings in Tailspin, see '''[https://github.com/tobega/tailspin-v0/blob/master/TailspinReference.md#string-literal string literal]''' in the Tailspin reference

def size: 'little';

'Mary had a $size; lamb' -> !OUT::write

 

=={{header|Tcl}}==

String interpolation is a fundamental operation of the Tcl language itself, and is carried out in a <tt>"</tt>double-quoted<tt>"</tt> program strings as well as bare-words. Thus, interpolation of the string from a variable is carried out with the <tt>$</tt> syntax and the string result of a command is interpolated with the <tt>[…]</tt> syntax.

puts "Mary had a $size lamb."

 

lindex $args [expr {int(rand()*[llength $args])}]

}

When more sophisticated control is required the <code>format</code> command can be used, which is very similar to the standard [[C]] library's <code>sprintf</code> function:

 

A third approach is to use <code>string map</code>.

 

Tcl also supports variable variable names. Even more powerful is nested interpolation with the <tt>subst</tt> command.

set daddy myself; set mommy {lil' bro}

set fun1 \[string\ to

set middle upper

set fun3 {aNd]}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

 

PRINT sentence_old

PRINT sentence_new

{{out}}

<pre>

Within the Unix shell, interpolation only occurs within doublequotes. Strings enclosed in singlequotes will not be subject to interpolation. Note that within the shell, a string may be used bare. If this is done each word within the string is treated separately, and any variable references or escape sequences will be substituted for their values:

 

echo Mary had a $extra lamb.

echo "Mary had a $extra lamb."

 

A ''parameter substitution'', like <code>$extra</code> or <code>${extra}</code>, interpolates its value into some string. This happens outside quotes or inside "double quotes". The other form of interpolation is [http://www.openbsd.org/cgi-bin/man.cgi?query=printf&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html printf(1)] with <code>%s</code>.

 

==={{header|C Shell}}===

echo Mary had a $extra lamb.

echo "Mary had a $extra lamb."

 

C Shell has <code>$extra</code> and <code>${extra}</code>. There are also modifiers, like <code>$file:t</code>; [http://www.openbsd.org/cgi-bin/man.cgi?query=csh&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html csh(1) manual] explains those.

=={{header|Ursala}}==

Expressions like this

evaluate to a list of character strings beginning with <code>foo</code> and ending

with <code>bar</code>, where <code>foo</code> and <code>bar</code> are literal text (possibly multiple lines)

and <code>x</code> is any expression evaluating to a list of character

strings. Using a dot like this

makes it a function returning a list of character strings consisting

of the output from the function <code>f</code> bracketed by the literal text <code>foo</code>

and <code>bar</code>. In this task, the identity function, <code>~&</code>, is used for <code>f</code>.

 

#show+

 

These operators are parsed like parentheses.

{{out}}

 

=={{header|Vala}}==

string size = "little";

print(@"Mary had a $size lamb\n");

stdout.printf("Mary had a %s lamb\n", size);

 

{{out}}

 

=={{header|Verbexx}}==

//

// The @INTERPOLATE verb processes a string with imbedded blocks of code. The code

@SAY (@INTERPOLATE "Mary had a { v } lamb");

 

 

=={{header|Visual Basic .NET}}==

 

Dim name as String = "J. Doe"

Dim balance as Double = 123.45

Dim prompt as String = String.Format("Hello {0}, your balance is {1}.", name, balance)

Console.WriteLine(prompt)

 

=={{header|Wren}}==

var t = "Mary had a %(s) lamb"

 

{{out}}

 

=={{header|Vlang}}==

txt := "little"

str := "Mary had a $txt lamb"

println(str)

 

=={{header|XPL0}}==

[X:= "little";

Text(0, "Mary had a "); Text(0, X); Text(0, " lamb.");

 

=={{header|zkl}}==

Generates a new string. For more info, refer to manual in the downloads section of [http://zenkinetic.com/ zenkinetic.com zkl page]