String interpolation (included)

Given a string and defined variables or values, string interpolation is the replacement of defined character sequences in the string by values or variable values.

For example, given an original string of "Mary had a X lamb.", a value of "big", and if the language replaces X in its interpolation routine, then the result of its interpolation would be the string "Mary had a big lamb".

(Languages usually include an infrequently used character or sequence of characters to indicate what is to be replaced such as "%", or "#" rather than "X").

The task is to

Use your languages inbuilt string interpolation abilities to interpolate a string missing the text "little" which is held in a variable, to produce the output string "Mary had a little lamb".
If possible, give links to further documentation on your languages string interpolation features.

Note: The task is not to create a string interpolation routine, but to show a language's built-in capability.

Ada

<lang Ada>with Ada.Strings.Fixed, Ada.Text_IO; use Ada.Strings, Ada.Text_IO; procedure String_Replace is

  Original : constant String := "Mary had a @__@ lamb.";
  Tbr : constant String := "@__@";
  New_Str : constant String := "little";
  Index : Natural := Fixed.Index (Original, Tbr);

begin

  Put_Line (Fixed.Replace_Slice (
    Original, Index, Index + Tbr'Length - 1, New_Str));

end String_Replace;</lang>

Alternatively

Aikido

<lang aikido>const little = "little" printf ("Mary had a %s lamb\n", little)

// alternatively println ("Mary had a " + little + " lamb")</lang>

ALGOL 68

Translation of: C

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

strings are simply flex arrays of char. formats on the other hand take on some of the properties of procedures including the scoping rules. <lang algol68>main:(

as a STRING #

 STRING extra = "little";
 printf(($"Mary had a "g" lamb."l$, extra));

as a FORMAT #

 FORMAT extraf = $"little"$;
 printf($"Mary had a "f(extraf)" lamb."l$);

or: use simply use STRING concatenation #

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

)</lang>

Output:

Mary had a little lamb.
Mary had a little lamb.
Mary had a little lamb.

AutoHotkey

<lang AutoHotkey>; Using the = operator LIT = little string = Mary had a %LIT% lamb.

Using the: = operator

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

MsgBox %string%</lang>

Documentation: Variables (see Storing values in variables and Retrieving the contents of variables)

AWK

String interpolation is usually done with functions sub() and gsub(). gawk has also gensub(). <lang AWK>#!/usr/bin/awk -f BEGIN { str="Mary had a # lamb." gsub(/#/, "little", str) print str }</lang>

Batch File

<lang dos>@echo off setlocal enabledelayedexpansion call :interpolate %1 %2 res echo %res% goto :eof

interpolate

set pat=%~1 set str=%~2 set %3=!pat:X=%str%! goto :eof</lang>

Demo <lang dos>>interpolate.cmd "Mary had a X lamb" little Mary had a little lamb</lang>

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.

<lang bracmat>@("Mary had a X lamb":?a X ?z) & str$(!a little !z)</lang>

C

Include the <stdio.h> header to use the functions of the printf family: <lang c>#include <stdio.h>

int main() {

 const char *extra = "little";
 printf("Mary had a %s lamb.\n", extra);
 return 0;

}</lang>

C++

<lang cpp>#include <string>

include <iostream>

int main( ) {

  std::string original( "Mary had a X lamb." ) , toBeReplaced( "X" ) ,
     replacement ( "little" ) ;
  std::string newString = original.replace( original.find( "X" ) ,

toBeReplaced.length( ) , replacement ) ;

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

}</lang>

C#

This is called "composite formatting" in MSDN.

<lang csharp>class Program {

   static void Main()
   {
       string extra = "little";
       string formatted = $"Mary had a {extra} lamb.";
       System.Console.WriteLine(formatted);
   }

}</lang>

Clojure

<lang lisp>(let [little "little"]

 (println (format "Mary had a %s lamb." little)))</lang>

COBOL

Works with: OpenCOBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. interpolation-included.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01  extra PIC X(6) VALUE "little".

      PROCEDURE DIVISION.
          DISPLAY FUNCTION SUBSTITUTE("Mary had a X lamb.", "X", extra)

          GOBACK
          .</lang>

Coco

As CoffeeScript, but the braces are optional if the expression to be interpolated is just a variable:

<lang coco>size = 'little' console.log "Mary had a #size lamb."</lang>

CoffeeScript

<lang coffeescript> size = 'little' console.log "Mary had a #{size} lamb." # Mary had a little lamb. console.log "Escaping: \#{}" # Escaping: #{} console.log 'No #{ interpolation} with single quotes' # No #{ interpolation} with single quotes

Multi-line strings and arbtrary expressions work: 20

console.log """

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

</lang>

Common Lisp

<lang lisp>(let ((extra "little"))

 (format t "Mary had a ~A lamb.~%" extra))</lang>

More documentation on the FORMAT function.

D

<lang d>void main() {

   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;

}</lang>

Output:

Mary had a little lamb.
Mary had a white little lamb.

More documentation on the format() function.

Delphi

<lang Delphi>program Project1;

uses

 System.SysUtils;

var

 Template : string;
 Marker : string;
 Description : string;
 Value : integer;
 Output : string;

begin

 // StringReplace can be used if you are definitely using strings
 // http://docwiki.embarcadero.com/Libraries/XE7/en/System.SysUtils.StringReplace
 Template := 'Mary had a X lamb.';
 Marker := 'X';
 Description := 'little';
 Output := StringReplace(Template, Marker, Description, [rfReplaceAll, rfIgnoreCase]);
 writeln(Output);

 // You could also use format to do the same thing.
 // http://docwiki.embarcadero.com/Libraries/XE7/en/System.SysUtils.Format
 Template := 'Mary had a %s lamb.';
 Description := 'little';
 Output := format(Template,[Description]);
 writeln(Output);

 // Unlike StringReplace, format is not restricted to strings.
 Template := 'Mary had a %s lamb. It was worth $%d.';
 Description := 'little';
 Value := 20;
 Output := format(Template,[Description, Value]);
 writeln(Output);

end.</lang>

Output:

Mary had a little lamb.
Mary had a little lamb.
Mary had a little lamb. It was worth $20.

DWScript

<lang delphi>PrintLn(Format('Mary had a %s lamb.', ['little']))</lang>

Output:

Mary had a little lamb.

E

<lang e>def adjective := "little" `Mary had a $adjective lamb`</lang>

The `...` syntax in general may be used as a sort of syntax extension; string interpolation is just the default case. More information on E quasi-literals. (Note that this documentation may be somewhat out of date.)

The above code is equivalent to (expands into):

<lang e>def adjective := "little" simple__quasiParser.valueMaker("Mary had a ${0} lamb").substitute([adjective])</lang>

If an identifier precedes the opening `, then it replaces simple; 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.

EchoLisp

format and printf use replacement directives to perform interpolation. See format specification in EchoLisp documentatiuon. <lang scheme>

format uses %a or ~a as replacement directive

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

  → "Mary had a little lamb"

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

  → "Mary had a little lamb"

</lang>

ECL

<lang ECL> IMPORT STD; STD.Str.FindReplace('Mary had a X Lamb', 'X','little'); </lang>

Elena

ELENA 3.2 : <lang elena>import extensions.

program = [

   var s := "little".
   console printLineFormatted("Mary had a {0} lamb.",s); readChar.

].</lang>

Elixir

Elixir borrows Ruby's #{...} interpolation syntax. <lang elixir> x = "little" IO.puts "Mary had a #{x} lamb" </lang>

Erlang

Output:

7> S1 = "Mary had a ~s lamb".
8> S2 = lists:flatten( io_lib:format(S1, ["big"]) ).
9> S2.
"Mary had a big lamb"

Euphoria

<lang euphoria>constant lambType = "little" sequence s s = sprintf("Mary had a %s lamb.",{lambType}) puts(1,s)</lang> See sprintf, printf

F#

Documentation <lang fsharp>let lambType = "little" printfn "Mary had a %s lamb." lambType</lang>

Factor

<lang factor>USE: formatting

SYMBOL: little

"little" little set

little get "Mary had a %s lamb" sprintf</lang>

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.

<lang factor>USE: formatting

CONSTANT: little "little"

little "Mary had a %s lamb" sprintf</lang>

Fantom

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

<lang fantom> fansh> x := "little" little fansh> echo ("Mary had a $x lamb") Mary had a little lamb </lang>

Documentation at: Fantom website

Fortran

<lang Fortran>program interpolate

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

contains

 elemental function inter(string,place,ins) result(new)
   character(len=*), intent(in)                          :: string,place,ins
   character(len=len(string)+max(0,len(ins)-len(place))) :: new
   integer                                               :: idx
   idx = index(string,place)
   if ( idx == 0 ) then
     new = string
   else
     new = string(1:idx-1)//ins//string(idx+len(place):len(string))
   end if
 end function inter

end program interpolate</lang>

FreeBASIC

FreeBASIC has a complex Print statement which, amongst other things, enables variables to be embedded in the string to be printed.

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: <lang freebasic>' FB 1.05.0 Win64

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

Dim x As String = "big" Print "Mary had a "; x; " lamb" FB's native Print statement x = "little" printf("Mary also had a %s lamb", x) Sleep</lang>

Output:

Mary had a big lamb
Mary also had a little lamb

Frink

<lang frink>x = "little" println["Mary had a $x lamb."]</lang>

FunL

<lang funl>X = 'little' println( "Mary had a $X lamb." )</lang>

Gambas

Click this link to run this code <lang gambas>Public Sub Main()

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

End</lang> Output:

Mary had a little lamb

Gastona

This kind of string interpolation is indeed a strong feature in Gastona. We add one more indirection in the sample just to ilustrate it. <lang gastona>#listix#

  <how>   //little
  <what>  //has a @<how> lamb
  
  <main>  //Mary @<what>

</lang>

Output:

Mary has a little lamb

Go

Doc: http://golang.org/pkg/fmt/ <lang go> package main

import (

   "fmt"

)

func main() {

   str := "Mary had a %s lamb"
   txt := "little"
   out := fmt.Sprintf(str, txt)
   fmt.Println(out)

} </lang>

Groovy

<lang groovy>def adj = 'little' assert 'Mary had a little lamb.' == "Mary had a ${adj} lamb."</lang>

Haskell

No such facilities are defined in Haskell 98, but the base package distributed with GHC provides a printf function.

<lang haskell>import Text.Printf

main = printf "Mary had a %s lamb\n" "little"</lang>

HicEst

Further documentation on HicEst string interpolation function EDIT() <lang hicest>CHARACTER original="Mary had a X lamb", little = "little", output_string*100

output_string = original EDIT(Text=output_string, Right='X', RePLaceby=little)</lang>

Icon and Unicon

Icon and Unicon are descended from a line of languages with a wealth of string manipulation capabilities. See The Icon Programming Language, 3rd Edition; Griswold and Griswold; Chapter 3 String Scanning <lang Icon> s2 := "humongous"

 s3 := "little"
 s1 :=  "Mary had a humongous lamb."
 s1 ?:= tab(find(s2)) || (=s2,s3) || tab(0)          # replaces the first instance of s2 with s3
 while s1 ?:= tab(find(s2)) || (=s2,s3) || tab(0)    # replaces all instances of s2 with s3, equivalent to replace</lang>

Library: Icon Programming Library

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.

J

The strings and printf scripts are part of the base library. <lang j> require 'printf'

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

Mary had a little lamb.

  require 'strings'
  ('%s';'little') stringreplace 'Mary had a %s lamb.'

Mary had a little lamb.

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

Mary had a little lamb.</lang>

Documentation:

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

<lang J> open'strings printf'</lang>

Alternatively, both strings and 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).

That said, note that in recent versions of J, strings is no longer a separate script but part of the core library.

Java

<lang java>String original = "Mary had a X lamb"; String little = "little"; String replaced = original.replace("X", little); //does not change the original String System.out.println(replaced); //Alternative: System.out.printf("Mary had a %s lamb.", little); //Alternative: String formatted = String.format("Mary had a %s lamb.", little); System.out.println(formatted);</lang>

JavaScript

<lang javascript>var original = "Mary had a X lamb"; var little = "little"; var replaced = original.replace("X", little); //does not change the original string</lang>

Or,

<lang javascript>// ECMAScript 6 var X = "little"; var replaced = `Mary had a ${X} lamb`;</lang>

jq

<lang jq>"little" as $x

 | "Mary had a \($x) lamb"</lang>

Any valid jq expression (including a pipeline) can appear between the interpolating parentheses, e.g.:<lang jq>$ jq -M -n -r '"Jürgen" as $x | "The string \"\($x)\" has \($x|length) codepoints."' The string "Jürgen" has 6 codepoints.</lang> Documentation: String interpolation

Julia

<lang julia>X = "little" "Mary had a $X lamb"</lang>

Kotlin

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

  val s = "little"
   // String interpolation using a simple variable
   println("Mary had a $s lamb")

   // String interpolation using an expression (need to wrap it in braces)
   println("Mary had a ${s.toUpperCase()} lamb")

   // However if a simple variable is immediately followed by a letter, digit or underscore
   // it must be treated as an expression
   println("Mary had a ${s}r lamb") // not $sr

}</lang>

Output:

Mary had a little lamb
Mary had a LITTLE lamb
Mary had a littler lamb

Lasso

Lasso doesn't really have built-in string interpolation, but you can use the built-in email mail-merge capability: <lang lasso>email_merge("Mary had a #adjective# lamb", map("token"="little", "adjective"=""), null, 'plain')</lang>

Output:

Mary had a little lamb

LiveCode

Livecode has a merge function for interpolation <lang LiveCode>local str="little" put merge("Mary had a str lamb.")

-- Mary had a little lamb.</lang>

Lua

Variable names

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:

<lang Lua>str = string.gsub( "Mary had a X lamb.", "X", "little" ) print( str )</lang>

Literal characters

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

<lang lua>print "Mary had a \n lamb" -- The \n is interpreted as an escape sequence for a newline</lang>

Mathematica

<lang Mathematica>Extra = "little"; StringReplace["Mary had a X lamb.", {"X" -> Extra}] ->"Mary had a little lamb."</lang>

Maxima

<lang maxima>printf(true, "Mary had a ~a lamb", "little");</lang>

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. <lang Nemerle>using System; using System.Console; using Nemerle.IO; // contains printf() and print()

module Stringy {

   Main() : void
   {
       def extra = "little";
       printf("Mary had a %s lamb.\n", extra);
       print("Mary had a $extra lamb.\n");
       WriteLine($"Mary had a $extra lamb.");
   }

}</lang>

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. <lang NetRexx>/* NetRexx */

options replace format comments java crossref savelog symbols

import java.text.MessageFormat import java.text.FieldPosition

useBif() useMessageFormat()

return

method useBif public static

 st = "Mary had a %1$ lamb."
 si = 'little'

 say st.changestr('%1$', si)

 return

method useMessageFormat public static

 result = StringBuffer()

 args = Object [                       -
   Object Integer(7),                  -
   Object Date(),                      -
   Object 'a disturbance in the Force' -
 ]
 msgfmt = MessageFormat('At {1, time} on {1, date}, there was {2} on planet {0, number, integer}.')
 result = msgfmt.format(args, result, FieldPosition(0))
 say result

 return

</lang>

Output:

Mary had a little lamb.
At 5:43:05 PM on Aug 22, 2011, there was a disturbance in the Force on planet 7.

Nim

<lang nim>import strutils

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

doesn't need an array for one substitution, but use an array for multiple substitutions</lang>

OCaml

The OCaml standard library provides the module Printf:

<lang ocaml>let extra = "little" in Printf.printf "Mary had a %s lamb." extra</lang>

OOC

In a String all expressions between #{...} will be evaluated. <lang ooc> main: func {

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

} </lang>

Oz

String interpolation is unidiomatic in Oz. Instead, "virtual strings" are used. Virtual strings are tuples of printable values and are supported by many library functions.

<lang oz>declare

 X = "little"

in

 {System.showInfo "Mary had a "#X#" lamb"}</lang>

PARI/GP

The Pari library has string interpolation, which extends C's: <lang C>GEN string_interpolate(GEN n) {

 pari_printf("The value was: %Ps.\n", n);
 GEN s = pari_sprintf("Storing %Ps in a string", n);

}</lang>

Works with: PARI/GP version version 2.4.4 and above

GP can also interpolate strings: <lang parigp>s=Strprintf("The value was: %Ps", 1<<20); printf("The value was: %Ps", 1<<20);</lang>

Perl

<lang perl>$extra = "little"; print "Mary had a $extra lamb.\n"; printf "Mary had a %s lamb.\n", $extra;</lang>

Perl 6

<lang perl6>my $extra = "little"; say "Mary had a $extra lamb"; # variable interpolation say "Mary had a { $extra } lamb"; # expression interpolation printf "Mary had a %s lamb.\n", $extra; # standard printf say $extra.fmt("Mary had a %s lamb"); # inside-out printf my @lambs = <Jimmy Bobby Tommy>; say Q :array { $$$ The lambs are called @lambs[]\\\.} # only @-sigiled containers are interpolated</lang>

Phix

<lang Phix>string size = "little" string s = sprintf("Mary had a %s lamb.",{size}) ?s</lang>

Output:

"Mary had a little lamb."

PHP

PicoLisp

<lang PicoLisp>(let Extra "little"

  (prinl (text "Mary had a @1 lamb." Extra)) )</lang>

PL/I

<lang PLI>*process or(!) source xref attributes;

sit: Proc Options(main);
/*********************************************************************
* Test string replacement
* 02.08.2013 Walter Pachl
*********************************************************************/
Dcl s Char(50) Var Init('Mary had a &X lamb. It is &X');
Put Edit(repl(s,'little','&X'))(Skip,A);

repl: Proc(str,new,old) Returns(Char(50) Var);
/*********************************************************************
* ooREXX has CHANGESTR(old,str,new[,count])
* repl follows, however, the translate "philosophy"
* translate(str,new,old) when old and new are just  a character each
* and replaces all occurrences of old in str by new
*********************************************************************/
Dcl str Char(*) Var;
Dcl (new,old) Char(*);
Dcl (res,tmp) Char(50) Var init();
Dcl p Bin Fixed(31);
tmp=str;                             /* copy the input string       */
Do Until(p=0);
  p=index(tmp,old);                  /* position of old in tmp      */
  If p>0 Then Do;                    /* found                       */
    res=res!!left(tmp,p-1)!!new;     /* append new to current result*/
    tmp=substr(tmp,p+length(old));   /* prepare rest of input       */
    End;
  End;
res=res!!tmp;                        /* final append                */
Return(res);
End;
End;</lang>

Output:

Mary had a little lamb. It is little

PowerShell

Using the format (-f) operator: <lang powershell>$extra = "little" "Mary had a {0} lamb." -f $extra</lang>

Using format string with the WriteLine static method <lang powershell>$extra = "little" [console]::writeline("Mary had a {0} lamb.", $extra)</lang>

Using the format method of the string type <lang powershell>$extra = "little" [string]::Format("Mary had a {0} lamb.", $extra)</lang>

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

Prolog

<lang Prolog>Extra = little, format('Mary had a ~w lamb.', [Extra]), % display result format(atom(Atom), 'Mary had a ~w lamb.', [Extra]). % ... or store it a variable</lang>

Using library(func) for SWI-Prolog:

<lang Prolog>Extra = little, Atom = 'Mary had a ~w lamb' $ Extra.</lang>

Using library(interpolate) for SWI-Prolog:

<lang Prolog>Extra = little, Atom = 'Mary had a $Extra lamb'.</lang>

PureBasic

The function ReplaceString() is built-in and can have both constants and variables as parameters. <lang PureBasic>ReplaceString("Mary had a X lamb.","X","little")</lang> Implemented in a program context <lang PureBasic>; String variable can be defined by appending .s to its name during definition or by appending and using $ as a part of its name. Define txt$, txtvar.s="little"

Load datasegment into variable txt$

Restore Mary Read.s txt$

Replace X with "little" and store result in txt$

txt$=ReplaceString(txt$,"X",txtvar)

OpenConsole(): Print(txt$)

DataSection:

 Mary:
 Data.s  "Mary had a X lamb."

EndDataSection</lang>

Python

Python has more than one inbuilt way of accomplishing the task. The methods have different capabilities that are not stretched by this small task

Using the % string interpolation operator: <lang python>>>> original = 'Mary had a %s lamb.' >>> extra = 'little' >>> original % extra 'Mary had a little lamb.'</lang>

Using the .format method of strings: <lang python>>>> original = 'Mary had a {extra} lamb.' >>> extra = 'little' >>> original.format(**locals()) 'Mary had a little lamb.'</lang> Using the format method, but replace by an expressions position as an argument to the format method call instead of by name: <lang python>>>> original = 'Mary had a {0} lamb.' >>> extra = 'little' >>> original.format(extra) 'Mary had a little lamb.'</lang>

Using the Template class of the string module: <lang python>>>> from string import Template >>> original = Template('Mary had a $extra lamb.') >>> extra = 'little' >>> original.substitute(**locals()) 'Mary had a little lamb.'</lang>

Racket

See the documentation on fprintf for more information on string interpolation in Racket.

lang racket

(format "Mary had a ~a lamb" "little") </lang>

REBOL

<lang rebol>str: "Mary had a <%size%> lamb" size: "little" build-markup str

REBOL3 also has the REWORD function

str: "Mary had a $size lamb" reword str [size "little"]</lang>

REXX

Interpolation does not occur in literal strings, neither within singlequote or doublequote enclosures.
However, interpolation can be emulated using the changestr function:

<lang rexx>/*REXX program to demonstrate string interpolation (string replacement).*/

                                      /*the string to be replaced is   */

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

                                      /*string and is  case  sensative.*/

original1 = "Mary had a X lamb." new1 = changestr('X', original1, replace) say 'original1 =' original1 say 'replaced =' new1 say

original2 = "Mary had a % lamb." new2 = changestr('%', original2, replace) say 'original2 =' original2 say 'replaced =' new2 say

original3 = "Mary had a $$$ lamb." new3 = changestr('$$$',original3,replace) say 'original3 =' original3 say 'replaced3 =' new3 say

original4 = "Mary had a someKindOf lamb." new3 = changestr('someKindOf', original4, "little") say 'original4 =' original4 say 'replaced4 =' new3

                                      /*stick a fork in it, we're done.*/</lang>

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

output

original1 = Mary had a X lamb.
replaced  = Mary had a little lamb.

original2 = Mary had a % lamb.
replaced  = Mary had a little lamb.

original3 = Mary had a $$$ lamb.
replaced3 = Mary had a little lamb.

original4 = Mary had a someKindOf lamb.
replaced4 = Mary had a little lamb.

Ring

<lang ring> aString =substr("Mary had a X lamb.", "X", "little") see aString + nl </lang>

Ruby

<lang ruby>irb(main):001:0> extra = 'little' => "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 => "Mary had a little lamb."</lang>

Documentation:

string_spec.rb describes interpolation using #{....} in double-quoted strings.
Core API describes printf-style interpolation by String#% and Kernel#sprintf.

Run BASIC

<lang runbasic>a$ = Mary had a X lamb." a$ = word$(a$,1,"X")+"little"+word$(a$,2,"X") </lang>

Rust

Rust has very powerful string interpolation. Documentation here. <lang rust>fn main() {

   println!("Mary had a {} lamb", "little");
   // You can specify order
   println!("{1} had a {0} lamb", "little", "Mary");
   // Or named arguments if you prefer
   println!("{name} had a {adj} lamb", adj="little", name="Mary");

}</lang>

Scala

Library: Scala

<lang Scala>object StringInterpolation extends App {

 import util.matching.Regex._
 val size = "little"

 { // Method I (preferred)
   // Scala 2.10.0 supports direct string interpolation
   // by putting "s" at the beginning of the string.
   println("V2.10+  : " + s"Mary had a $size lamb,")
 }

 { // Method II
   // Pre Scala 2.10 indirect use of Java Class Formatter
   val originalFormatter = "Mary had a %s lamb,"
   println("V2.10- 1: " + originalFormatter format size)
   // Above mentioned is Scala's postfix notation and equivalent for: 
   println("V2.10- 2: " + originalFormatter.format(size))
   // Also possible
   printf(("V2.10- 3: " + originalFormatter + '\n').format(size))
   // All will be expanded to
   print(("V2.10- 3: " + originalFormatter + '\n').format(size))
   print((new java.util.Formatter).format("V2.10- 4: " + originalFormatter + '\n', size))
 }

 { // Method III
   // Regular expressions, only for demonstration
   val extractor = """\$\{([^}]+)\}""".r
   println((extractor.replaceAllIn("Regex  1: Mary had a ${x} lamb,", "snow white")))

   // RegEx freaking
   def interpolate(text: String, vars: (String, String)*) =
     extractor.replaceAllIn(text,
       _ match { case Groups(v) => vars.toMap.getOrElse(v, "" /*in case nothing provided*/ ) })

   println(interpolate("Regex  2: ${who} had a ${size} ${pet}, ${unknown}",
     ("pet", "lamb"), ("size", "fat"), ("size", "humongous"), ("who", "Mary")))
 }

 { // Method IV, not recommended.
   // Standard API method, search argument (1st ones) supposed to be a regular expression
   println("Replace1: " + "Mary had a ${x} lamb".replaceAll("""\$\{x\}""", size))
   // Standard API method, literally, on regular expression
   println("Replace2: " + "Mary had a ${x} lamb".replaceAllLiterally("${x}", size))
 }

 { // Method IV, not recommended.
   println("Split   : " + "Mary had a ${x} lamb.".split("""\$\{([^}]+)\}""").mkString(size))
 }

}</lang> Documentation:

Scala 2.10.0: string interpolation

Sed

<lang bash>#!/bin/bash

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

echo "$1" | sed "s/ X / $2 /g"</lang>

Seed7

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

const proc: main is func

 local
   const string: original is "Mary had a X lamb";
   const string: little is "little";
   var string: replaced is "";
 begin
   replaced := replace(original, "X", little);
   writeln(replaced);
 end func;</lang>

Output:

Mary had a little lamb

Sidef

<lang ruby>var extra = 'little'; say "Mary had a #{extra} lamb";</lang>

or: <lang ruby>say ("Mary had a %s lamb" % 'little');</lang>

See: documentation

SNOBOL4

Every statement in SNOBOL can is a subset of pattern replacement having a subject (s1 in this case), object (s2), and replacement (s3). <lang snobol> s1 = "Mary had a humongous lamb." s2 = "humongous"

       s3 = "little"

s1 s2 = s3 end</lang> See The SNOBOL4 Programming Language; Griswold, Poage, Polonsky; Chapter 2 Pattern Matching

Swift

<lang swift>let extra = "little" println("Mary had a \(extra) lamb.")</lang>

Tcl

String interpolation is a fundamental operation of the Tcl language itself, and is carried out in a "double-quoted" program strings as well as bare-words. Thus, interpolation of the string from a variable is carried out with the $ syntax and the string result of a command is interpolated with the […] syntax. <lang tcl>set size "little" puts "Mary had a $size lamb."

proc RandomWord {args} {

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

} puts "Mary had a [RandomWord little big] lamb."</lang> When more sophisticated control is required the format command can be used, which is very similar to the standard C library's sprintf function: <lang tcl>puts [format "Mary had a %s %s." [RandomWord little big] [RandomWord lamb piglet calf]]</lang>

A third approach is to use string map. <lang tcl>set s "Mary had a @SIZE@ lamb." puts [string map {@SIZE@ "miniscule"} $s]</lang>

Tcl also supports variable variable names. Even more powerful is nested interpolation with the subst command. <lang tcl>set grandpa {$daddy}; set grandma \$mommy set daddy myself; set mommy {lil' bro} set fun1 \[string\ to set fun2 lower set lower middle set middle upper set fun3 {aNd]} puts [subst "$grandpa $fun1$[subst $$fun2] $fun3 $grandma"]</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT

sentence_old="Mary had a X lamb."

values=* DATA little DATA big

sentence_new=SUBSTITUTE (sentence_old,":X:",0,0,values) PRINT sentence_old PRINT sentence_new </lang>

Output:

Mary had a X lamb.
Mary had a little lamb.

UNIX Shell

Works with: Bourne Shell

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:

<lang sh>extra='little' echo Mary had a $extra lamb. echo "Mary had a $extra lamb." printf "Mary had a %s lamb.\n" $extra</lang>

A parameter substitution, like $extra or ${extra}, interpolates its value into some string. This happens outside quotes or inside "double quotes". The other form of interpolation is printf(1) with %s.

The shell has more forms of parameter substitution, like ${tea:?no tea}. Your shell's manual explains those. For the original Bourne Shell, sh(1) manual explains those.

C Shell

<lang csh>set extra='little' echo Mary had a $extra lamb. echo "Mary had a $extra lamb." printf "Mary had a %s lamb.\n" $extra</lang>

C Shell has $extra and ${extra}. There are also modifiers, like $file:t; csh(1) manual explains those.

Ursala

Expressions like this <lang Ursala>-[foo-[ x ]-bar]-</lang> evaluate to a list of character strings beginning with foo and ending with bar, where foo and bar are literal text (possibly multiple lines) and x is any expression evaluating to a list of character strings. Using a dot like this <lang Ursala>-[foo-[. f ]-bar]-</lang> makes it a function returning a list of character strings consisting of the output from the function f bracketed by the literal text foo and bar. In this task, the identity function, ~&, is used for f. <lang Ursala>x = <'little'>

show+

main = -[Mary had a -[. ~& ]- lamb.]- x</lang> These operators are parsed like parentheses.

Output:

Mary had a little lamb.

VBA

Here are 2 examples:

With Replace

a="little"
debug.print replace("Mary had a X lamb","X",a)  'prints Mary had a little lamb

Replace

With Interpolation function

Sub Main()
    a="little"
    debug.print Format("Mary had a {0} lamb",a)
End Sub

Public Function Format(ParamArray arr() As Variant) As String
    Dim i As Long, temp As String
    temp = CStr(arr(0))
    For i = 1 To UBound(arr)
        temp = Replace(temp, "{" & i - 1 & "}", CStr(arr(i)))
    Next
    Format = temp
End Function

CStr UBound ParamArray

zkl

<lang zkl>"Mary had a X lamb.".replace("X","big")</lang> Generates a new string. For more info, refer to manual in the downloads section of zenkinetic.com zkl page