Here document: Difference between revisions

;Task:

Demonstrate the use of   ''here documents''   within the language.

 

;Related task:

*   [[Documentation]]

<br><br>

 

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

11l does not have here-docs. It does however have raw strings which can be used similarly.

here

doc

 

=={{header|8th}}==

Multiline strings are simply parsed using "quote", which parses first a character to use as a separator, and scans until that character is found:

quote *

Hi

there

* .

{{out}}

<pre>

A workaround is to use containers of strings:

 

 

procedure Here_Doc is

Ada.Text_IO.Put_Line(Document.Element(I));

end loop;

 

{{out}}

It can be crudely achieved using an array of strings:

 

 

[]STRING help = (

"Dammit. Janet, I love you."

))

 

{{out}}

Dammit. Janet, I love you.</pre>

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program heredoc.s */

pop {r0,r1,r2,r7,lr} @ restaur registers

bx lr @ return

 

=={{header|AutoHotkey}}==

AutoHotkey uses "continuation sections" for literal text:

 

MyVariable =

(

Variable references such as %MyVar% are expanded.

)

 

=={{header|AWK}}==

 

The awk extraction and reporting language does not provide any markup facility for embedding here documents within an awk script. The awk utility is really a helper tool often used from within the Unix shell. The Unix shell in which awk scripts are usually embedded does support the use of here documents, and the way that here documents are used within the shell make them ideal for passing to awk as is, without the need for an additional facility in awk.

 

=={{header|Bracmat}}==

Strings in Bracmat can continue over many lines. They start and end with a quote. Quotes in the text must be escaped with a reverse solidus, like the reverse solidus itself.

 

"

Second line

& out$("Multiline string:")

& out$(!stringA)

Output:

<pre>Multiline string:

 

=={{header|BaCon}}==

'--- we dont have a print here doc built-in command in BaCon

 

 

Output:

<pre>To use Bacon your system must have either Korn Shell, or ZShell, or Bourne Again Shell (BASH) available.

(including 64bit environments). It tries to revive the days of the good old BASIC.</pre>

 

 

 

<pre>

 

</pre>

 

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

C# has a string literal call which is used for heredoc functionality

 

 

class Program

in C#");

}

 

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

C++11 raw string literals are similar to heredocs, except there is no newline after the opening token or before the ending token (unless you actually want newlines there).

 

 

int main()

or recognized, and all whitespace is preserved.

)EOF";

 

=={{header|Clojure}}==

CoffeeScript borrows the triple-quoted string syntax from Python. Note that these strings strip leading whitespace in CoffeeScript, to allow you to neatly align the heredoc string.

 

Single-quoted heredocs allows no '#{foo}' interpolation.

This behavior is similar to single-quoted strings.

"""

 

 

{{out}}

[https://github.com/e-user/cl-heredoc cl-heredoc] provide read-macro for heredoc:

 

(ql:quickload 'cl-heredoc)

 

no matter how many lines or what characters until

the magic end sequence has been reached!eof1)

{{out}}

<pre>

 

Note: <code>NIL</code> is the return value of function <code>format</code> when first argument is <code>t</code>

 

=={{header|D}}==

 

void main() {

 

// std.string.outdent is used to remove the four spaces indent.

{{out}}

<pre>a string that you "don't" have to escape

=={{header|DWScript}}==

Double-quotes (") denote a multi-line string, to include a double-quote in such a string, you need to double it.

a multiline

""string""

{{out}}

<pre>This is

"string"

sample</pre>

 

=={{header|EchoLisp}}==

=={{header|Elixir}}==

In Elixir, one can use either a pair of triple single-quotation marks or a pair of triple double-quotation marks, but in both cases, string interpolation occurs:

привет

мир

 

Here is an illustrative iex transcript:

2

iex(2)> '''

** (SyntaxError) iex:3: heredoc start must be followed by a new line after '''

 

=={{header|Erlang}}==

Multiline strings look like this in the Erlang shell:

2> S = " ad

2> 123

123

the end

 

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

=={{header|Factor}}==

Factor strings surround by '"' are multiline, but accept escape sequences (like "\n", "\uxxxxxxxx"). Strings surrounded by '"""' don't have to escape '"'. Use HEREDOC: (and other variants, like <pre>[[</pre>) for verbatim text

string\n(with escape sequences: \u{greek-capital-letter-sigma})

"

this

is not \n escaped at all

 

[[ this also works , but needs a space at the start (but not the end)]]

===version 1===

{{works with|GForth}}

\ under+ ( a b c -- a+c b) , latest ( -- nt ) , name>string ( nt -- ca u )

\ Should not be a problem to modify it to work with other Forth implementation:

>> RABBIT

RABBIT

 

<pre>

 

It's written to works with Forth's default implementation of counted strings. Those are limited to 255 characters, which is fine in many cases, but on the short side for here documents, so therefore we temporarily redefine them to use a full cell for size (16 bits would probably be ideal) while compiling the here document words.

: place over >r rot over cell+ r> move ! ;

: +place 2dup >r >r dup @ cell+ + swap move r> r> dup @ rot + swap ! ;

~~ end ~~

 

 

{{out}}

 

Producing a source file containing a block of text that will be presented as output in the same layout (new lines and all) is only possible if the added layout stuff (generating the required new line starts) and delimiters in the source are disregarded. But if one accepts a few constraints, the following shows a possible approach:

INTEGER I !A stepper.

CHARACTER*666 I AM !Sufficient space.

END DO !On to the next line.

END

With old-style fixed-format source, rather amusingly there is space for sixty-six characters of text per line and so this is the canvas. Any usage of tab characters must be resolved into spaces (and some compilers count up to 72 oddly when tabs are involved) and likewise with new lines. A surprise was provided to an old-time card flapper when it became apparent that trailing spaces were ''not'' being incorporated into the text literal unless the "<col72" markers were appended to column seventy-two of the source. An old-time card deck copied to disc and with the sequence numbers in columns 73-80 removed (as no-one is going to drop a disc file so some storage space can be saved) might thereby compile incorrectly! Similarly, the source text highlighter here does not fully recognise the odd tricks available for Fortran syntax, apparently deeming the comments a part of a text literal. The F90 compiler's highlighting does, and shows that text beyond column 72 is not Fortran code.

 

In Pascal, the only forbidden character in string literals is the newline character.

However, as of 2019‑09‑06 in a trunk version of the FPC (Free Pascal compiler) support for string literals spanning multiple lines can be enabled.

 

=={{header|Frink}}==

Frink does not have awkward here-docs. Triple-quoted strings serve the same purpose, but more concisely. (The Perl, PHP, etc. syntax for here-documents is a violation of the "define everything at most once" principle of software engineering.) Variable interpolation is allowed within triple-quoted strings.

lyrics = """Oh, Danny Boy,

The pipes, the pipes are calling

From glen to glen and down the mountainside"""

 

=={{header|Genie}}==

Genie includes triple quoted verbatim strings and "at" quoted template strings, which can be used as Heredoc data in source. Given the limitation of terminating quotes not being a user defined sequence, inner quotations will need to be escaped or transcluded.

 

/*

Here documents, as template and verbatim strings in Genie

 

stdout.printf("%s", multilineString)

 

{{out}}

Go does not have here documents. Multiline string literals serve this purpose.

 

 

 

=={{header|Groovy}}==

===Multi-line String literal===

The literal text, preserving lines and spacing

Time's a strange fellow;

more he gives than takes

losing, gaining

--love! if a world ends

 

{{out}}

===Multi-line GString expression===

Like single-line GString expressions, any subexpression delimited with ${ } is substituted with its "toString()" value. Preserves lines and spacing outside of the subexpressions.

def horse='stallion'

def christ='Jesus'

how do you like your blueeyed boy

Mister Death

 

{{out}}

You could use [https://hackage.haskell.org/package/raw-strings-qq raw-strings-qq], or alternatively:

 

 

main :: IO ()

]

 

 

Output:

 

=={{header|J}}==

0 :0 will be replaced by the text on the following lines.

This is three tokens: two instances of the number 0 and

note that this mechanism is significantly more verbose than using

the underlying 0 :0 mechanism directly.

 

=={{header|JavaScript}}==

ES6 introduced template literals. These are string literals that suport multi-line text and can include

interpolated expressions using ${···} syntax. It is indicated with the backtich character [`]

const tempLit = `Here is some

multi-line string. And here is

That's all.`;

console.log(tempLit)

 

<pre>Here is some

No special syntax is required to support "here documents" in jq in that any JSON string, and indeed any string specifier (as explained below), can be presented using a multiline format.

 

def s:

"x

z";

 

{{Out}}

 

String specifiers, that is possibly non-JSON strings which incorporate references to jq expressions, are handled in the same way. For example, the following program produces the same result:

"x

\(a)

z";

 

 

Most control characters, such as Control-A and Control-Z, can also be presented literally, but the RosettaCode.org editor disallows them in general, so the next example only shows an embedded literal tab:

tab: end

parens:()

double quotation mark must be escaped:\"

b

{{out}}

 

=={{header|Julia}}==

Like Python, Julia has triple-quoted string literals, which are similar to here-docs:

 

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

 

=={{header|Kotlin}}==

 

Here's an example of all this:

 

fun main(args: Array<String>) {

 

println(here)

 

{{out}}

Lambdatalk inverts the standard evaluation process, nothing is evaluated out of S-expressions {first rest}.

 

1) defining a variable:

{def myVar 123}

the value of "myVar": 123

That's all.

 

=={{header|langur}}==

 

 

We put our text here.

Here we are, Doc.

 

We can also use this with a regex literal. Note that this does not make the regex pattern "free-spacing." Use the x modifier for that.

 

a regex pattern here

Still here, Doc.

 

a free-spacing regex pattern here

Somewhere, Doc.

 

=={{header|Lingo}}==

But you can define multi-line strings using the line continuation character "\":

 

This is the second line.\

This "&QUOTE&"line"&QUOTE&" contains quotes."

 

{{out}}

<pre>

</pre>

 

 

=={{header|Lua}}==

Lua uses the [ [ to mark the start of a dochere block and ] ] to mark the end. It can be used directly or while assigning strings to a variable. An arbitrary but matching number of = may be placed between the brackets in both delimiters to allow ] ] to appear in the string.

print([[

This is a long paragraph of text

print(msg)

 

 

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

A block of { } can be used for code and for text. Editor in M2000 environment can color code/string on the fly, analyzing the first line, where the block start.

Module Checkit {

a$={This is the first line

}

CheckIt

 

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

is an

interesing

when not

back\

{{out}}

<pre>Mathematica

when not

backs\ashed!</pre>

 

=={{header|NewLISP}}==

; oofoe 2012-01-19

; http://rosettacode.org/wiki/Here_document

[/text] "James" "magician" "doctor" "L. McCoy"))

 

 

{{out}}

 

There are no heredocs, but triple-quoted-strings can be used:

-h Display this usage message

-H hostname Hostname to connect to

 

=={{header|NMAKE.EXE}}==

command0 <<

temporary, discarded inline file

named and preserved inline file

...

 

=={{header|OCaml}}==

 

print_string {whatever|

'hahah', `this`

|whatever}

;;

{{out}}

<pre>

In Perl, there must not be a space between the "<<" and the token string. By default, the ending token must the entire end line (i.e. no surrounding spaces) for it to be recognized (but see exception below). Interpolation is allowed, like a double-quoted string:

 

1, High Street,

$town_name,

West Midlands.

WM4 5HD.

 

If the token string contains spaces, the token after the "<<" must be quoted; otherwise the double-quotes is implicit:

egg

milk

flour

 

It is possible to make a here-document that behaves differently than a double-quoted string, by applying a different kind of quoting to the token. For example, if you use single quotes, then the here document will not support interpolation, like a normal single-quoted string:

 

No

$interpolation

here

 

Alternately, you can use backticks to cause the here document to be executed

and the result returned, just like a normal backtick operator:

 

ls /home

 

Note that in the above examples, that a semicolon was left

nested expression:

 

Mary had

a little

 

Since Perl 5.26, the here document can be indented by putting a '~' before the token. All spaces to the left of the ending token then become insignificant. This avoids having a disconcerting exdent in the middle of your code.

 

print <<~END;

Mary had

lamb

END

 

=={{header|Phix}}==

Phix does not have here-docs. In Phix normal double quoted strings are single line and require escaping. Strings can also be entered by using triple doublequotes or single backticks to include linebreaks and avoid any backslash interpretation. If the literal begins with a newline, it is discarded and any immediately following leading underscores specify a (maximum) trimming that should be applied to all subsequent lines. Interpolation is left to printf and friends. Both """`""" and `"""` are valid. Examples:

{{out}}

<pre>

Interpolation is allowed, like a double-quoted string:

 

1, High Street,

$town_name,

West Midlands.

WM4 5HD.

 

In PHP 5.3+, it is possible to make a here-document that does not interpolate

(like in Perl):

 

No

$interpolation

here

 

=={{header|PicoLisp}}==

We can use the '[http://software-lab.de/doc/refH.html#here here]' function:

 

(prinl "### This is before the text ###")

(here "TEXT-END")

TEXT-END

 

 

{{out}}

The Key is the At symbol @.

 

$XMLdata=@"

<?xml version="1.0" encoding="utf-8"?>

</unattend>

"@

 

=={{header|Python}}==

It does however have [http://docs.python.org/py3k/tutorial/introduction.html#strings triple-quoted strings] which can be used similarly.

 

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

 

=={{header|Racket}}==

that this implies (breaks code indentation, no "interpolation"):

 

#lang racket/base

 

EOF

)

{{out}}

<pre> Blah blah blah

that works well with code:

 

#lang at-exp racket/base

 

(output @list|<<{And customizable delimiters

so @foo{} is just plain text}>>|)

{{out}}

<pre>Blah blah blah

The indentation of the end marker is removed from every line.

 

say qq :to 'END';

some line

color: $color

another line

{{out}}

<pre>some line

Multiple here docs may be stacked on top of each other.

 

sub freewheelin() {

print q :to 'QUOTE', '-- ', qq :to 'AUTHOR';

}

 

 

{{out}}

Both q and qq are specialised forms of [http://design.raku.org/S02.html#Q_forms Q] which comes with many adverbs. Here a heredoc that only interpolates @-sigils.

 

say Q :array :to 'EOH';

123 \n '"`

@a$bc

@a[]

 

{{out}}

=={{header|Raven}}==

As a list:

'Spike' as recipient

 

"%(sender)s

] "\n" join print

Using group to place the data on the stack:

'Spike' as recipient

 

%(sender)s\n"

list "\n" join print

{{out}}

<pre>Dear Spike,

 

=={{header|REXX}}==

parse arg doc . /*"here" name is case sensitive. */

 

└─────────┘

◄◄.

{{out}} when using the input of: <tt> rs-232 </tt>

<pre>

 

=={{header|Ring}}==

text ="

<<'FOO'

to come to the aid of their country."

see text + nl

Output:

<pre>

Interpolation is allowed, like a double-quoted string:

 

1, High Street,

#{town_name},

West Midlands.

WM4 5HD.

 

If the token string contains spaces, the token after the "<<" must be quoted; otherwise the double-quotes is implicit:

 

egg

milk

flour

 

It is possible to make a here-document that behaves differently than a double-quoted string, by applying a different kind of quoting to the token.

For example, if you use single quotes, then the here document will not support interpolation, like a normal single-quoted string:

 

No

#{interpolation}

here

 

Alternately, you can use backticks to cause the here document to be executed

and the result returned, just like a normal backtick operator:

 

ls /home

 

The here document does not start immediately at the "<<END" token -- it starts on the next line.

To further illustrate this fact, we can use the "<<END" inside a complex, nested expression:

 

Mary had

a little

 

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

<<'FOO'

Now

good mem

to come to the aid of their country."

{{out}}

<pre><<'FOO'

Similar to [[#C++|C++]], Rust offers raw strings. In a manner resembling [[#Lua|Lua]]'s delimiters, an arbitrary but matching number of # on both ends may be used to allow inclusion of # into the string:

 

This is a "raw string literal," roughly equivalent to a heredoc.

"#;

This string contains a #.

"##;

 

=={{header|Scala}}==

Triple quotes (""") marks the beginning and end.

Specially handy when using escape sequences in e.g. regular expressions.

val MemoriesOfHolland=

"""Thinking of Holland

|with its lapping disasters

|is feared and hearkened.""".stripMargin

All control codes are transparent e.g. new lines.

In order for a neat code each lines has as prefix spaces and a | symbol

which will be removed by the stripMargin function.

 

=={{header|SenseTalk}}==

SenseTalk has "block quotes" for large blocks of text, enclosed between <nowiki>"{{"</nowiki> (at the end of a line) and "}}" (at the beginning of a line). A tag can also be used after the <nowiki>"{{"</nowiki> and before the "}}" which allows for nesting of blocks, such as for a block of code containing other block quotes.

 

set script to {{SCRIPT

put "Script demonstrating block quotes"

do script

 

 

=={{header|SequenceL}}==

"In SequenceL

strings are

characters are

valid for inclusion

 

{{out}}

When the token string is double-quoted ("") or not quoted,

the content will be interpolated like a double-quoted string:

a = #{1+2}

b = #{3+4}

 

If single quotes are used, then the here document will not support interpolation, like a normal single-quoted string:

No

#{interpolation}

here

The here document does not start immediately at the "<<END" token -- it starts on the next line. The "<<END" is actually an expression, whose value will be substituted by the contents of the here document.

To further illustrate this fact, we can use the "<<END" inside a complex, nested expression:

Mary had

a little

which is equivalent with:

Mary had

a little

EOF

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

With SQL only from command line. The single quote string is opened along the three lines:

db2 "select 'This is the first line.

This is the second line.

This is the third line.' from sysibm.sysdummy1"

Output:

<pre>

</pre>

With SQL only from script with concat function (one row):

select 'This is the first line.' || chr(10) ||

'This is the second line.' || chr(10) ||

'This is the third line.' from sysibm.sysdummy1;

Output:

<pre>

</pre>

With SQL only from script with union operator (three rows):

select 'This is the first line.' from sysibm.sysdummy1

union

union

select 'This is the third line.' from sysibm.sysdummy1;

Output:

<pre>

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

SET serveroutput ON

CALL DBMS_OUTPUT.PUT_LINE('This is the first line.' || chr(10) ||

'This is the second line.' || chr(10) ||

'This is the third line.');

Output:

<pre>

 

=={{header|Tcl}}==

In Tcl, the {curly brace} notation is strictly a here-document style notation

as it permits arbitrary content inside it *except* for an unbalanced brace.

plus all whitespace at the start of the next line

to be compressed to a single space.

 

If substitution is desired within the document, it should either be written

to the resulting script which are interpreted by txr.

 

@(maybe)

@(bind USER "Unknown User")

 

The Computer

 

Test runs

{{works with|Bourne Shell}}

 

cat << ANARBITRARYTOKEN

The river was deep but I swam it, Janet.

I've one thing to say and that's ...

Dammit. Janet, I love you.

 

Here documents do parameter and command substitution:

* Your HOME is $HOME

* 2 + 2 is `expr 2 + 2`

* Backslash quotes a literal \$, \` or \\

 

cat <<- EOF

The <<- variant deletes any tabs from start of each line.

EOF

 

If TOKEN has any quoted characters (like 'TOKEN', "TOKEN" or \TOKEN),

then all $ ` \ in the here document are literal characters.

 

$PATH \$PATH `shutdown now`

In any unix shell, you specify a text block and can use all whitespace like

(spaces) & (tab) in it, by using single quotes.

conform to the task definition.

'

 

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

cat << ANARBITRARYTOKEN

* Your HOME is $HOME

cat << 'ANARBITRARYTOKEN'

$PATH \$PATH `shutdown now`

 

=={{header|Ursala}}==

 

-[

the periods like this -[.. ~&]-. This one is a second order function

that needs to be applied to another function in order to get a

 

=={{header|VBScript}}==

 

It will prompt you to select a Txt-based file and do its best to create VBScript code that will recreate that Txt-based file!

'Purpose: Converts TXT files into VBS code with a function that returns a text string with the contents of the TXT file

' The TXT file can even be another VBS file.

 

WshShell.Popup "created " & strFileNameOUT, 3, "Completed", 64

 

=={{header|Wren}}==

 

 

 

 

{{out}}

<pre>

`Have fun!`

</pre>

 

=={{header|XPL0}}==

Text(0, " ^"Heredocs^" are pretty much automatic. Multiple lines and

whitespace, such as indentations, are output exactly as written. Quote

 

=={{header|XSLT}}==

Being a dialect of XML, XSLT inherits [http://www.w3.org/TR/REC-xml/#sec-cdata-sect CDATA sections]. Not quite heredocs, these are more like raw triple quotes in Python (<code>r"""…"""</code>) or Scala (<code>"""…"""</code>) in that anything except the end delimiter is treated literally.

 

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="text"/>

]]>

</xsl:template>

 

Output from xsltproc (input is ignored):

 

</pre>

 

=={{header|zkl}}==

#<<<

"#<<< starts a block of lines that are concatenated verbatim

Note that is isn't a string, but arbitrary source " + 1 + 23;

#<<<

{{out}}

<pre>

{{omit from|BASIC}}

{{omit from|BBC BASIC}}

{{omit from|Déjà Vu}}

{{omit from|Gambas}}