Long literals, with continuations: Difference between revisions

{{Template:Strings}}

<br><br>

=={{header|6502 Assembly}}==

There is no need for continuation codes, as the language interprets a contiguous data block as a single entity, whether you intended it to be or not. If you had two consecutive strings embedded in the code and you forgot the null terminator on the first one, trying to print just the first string would print both. For example:

 

db "Hello World" ;no null terminator

GoodbyeString:

db "Goodbye World!",0

 

The output would be as follows, assuming the <code>PrintString</code> routine uses a null terminator to know when a string ends:

<pre>

Hello WorldGoodbye World!

</pre>

 

Since each string is of variable length, it is much easier to make a lookup table of the elements ordered by atomic number, with each element in the lookup table being a pointer to the actual string consisting of that element's name.

 

dw neon,sodium,magnesium,aluminum,silicon,phosphorous,sulfur,chlorine,argon

dw potassium,calcium,scandium,titanium,vanadium,chromium,manganese,iron

Elements_End:

 

db 0

hydrogen:

helium:

lithium:

;etc.

 

RevisionDate:

 

Finally:

 

The required output can be obtained like so:

STA z_L ;store it in z_L, a zero page memory address

LDA #>RevisionDate ;get the high byte

JSR PrintString

 

 

LDA ElementCount

TAX ;use as an offset into the lookup table.

 

STA z_L

STA z_H

 

 

{{out}}

<pre>

118 elements, the last is oganesson

</pre>

 

 

 

 

=={{header|Arturo}}==

===Using concatenations===

 

elementString:

print ["Last revision date:" revDate]

print ["Number of elements:" size elements]

 

{{out}}

===Using string blocks===

 

elementString: {

print ["Last revision date:" revDate]

print ["Number of elements:" size elements]

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f LONG_LITERALS_WITH_CONTINUATIONS.AWK

BEGIN {

revised = "30JUN2020"

}

{{out}}

<pre>

first & last 30 characters: hydrogen helium lithium beryll & ivermorium tennessine oganesson

</pre>

=={{header|Crystal}}==

Crystal's <code>%w</code> literals create a whitespace-delimited array of strings at compile time

 

last_revision = Time.utc year: 2021, month: 2, day: 25

puts last_revision.to_s "last revised %B %e, %Y"

puts "number of elements: #{element_list.size}"

 

=={{header|Delphi}}==

{{libheader| System.StrUtils}}

{{Trans|Free Pascal}}

program Long_literals_with_continuations;

 

writeln(words[high(words)]);

readln;

{{out}}

<pre>Last update: 2020-11-11

The convention in Factor is to limit lines to 64 characters wide if possible. This constraint is sometimes waived for large literals, but it was easy enough to accommodate here.

{{works with|Factor|0.99 2020-03-02}}

 

qw{

"Last revision: %s\n" printf

[ length ] [ last ] bi

{{out}}

<pre>

ANSI strings are pointers to sequences of characters.

The data type includes a reference count and a (4-Byte long) <tt>length</tt> field.

program longStringLiteralDemo(output);

 

elementString, stdWordDelims));

end.

{{out}}

<pre>

oganesson

</pre>

 

=={{header|Go}}==

 

import (

lix := strings.LastIndex(elements2, " ") // get index of last space

fmt.Println("Last element : ", elements2[lix+1:])

 

{{out}}

Last element : oganesson

</pre>

 

=={{header|J}}==

│hydrogen helium lithium beryll│vermorium tennessine oganesson│

└──────────────────────────────┴──────────────────────────────┘</pre>

 

=={{header|jq}}==

# To add chemical elements, modify the CHEMICAL_ELEMENTS function,

# ensuring that the date is updated properly and that there is at least one

"Last element in list: \($a[-1])";

Invocation: jq -nrf program.jq

{{out}}

The task does not as of the current revision mention lower versus upper case, but the below is corrected per a request anyway.

The task does ask to comment on which column code may start. The start column for code does not matter to Julia, or to most modern computer language compilers, other than in some cases (not string data) Python.

 

# FOR FUTURE EDITORS:

 

report()

<pre>

File last revised (formatted as dateTtime): 2020-03-24T02:48:55.421 GMT

Kotlin has raw string literals with <code>"""</code>. It does not (yet) have a native date/time library, so we use Java’s here.

 

 

const val elementsChunk = """

println("Last element : ${elementsList.last()}")

println("The elements are : ${elementsList.joinToString(" ", limit = 5)}")

 

{{out}}

 

=={{header|Lua}}==

-- the long literal string is delimited by double square brackets: [[...]]

-- each word must be separated by at least one whitespace character

 

-- then, if still required, produce a single-space-between string version:

{{out}}

<pre>revised date: February 2, 2021

 

===Using concatenations===

 

const RevDate = "2021-02-05"

echo "Last revision date: ", RevDate

echo "Number of elements: ", ElementList.len

 

{{out}}

 

===Using a long literal string===

 

const RevDate = "2021-02-05"

echo "Last revision date: ", RevDate

echo "Number of elements: ", ElementList.len

 

{{out}}

=={{header|Perl}}==

Mostly pointless...

 

use strict; # https://rosettacode.org/wiki/Long_literals,_with_continuations

element count: $count

last element: $last

{{out}}

<pre>

You could also, like Julia, use get_file_date(command_line()[2]) instead of the hand-written last_updated constant. Phix code is free-format, indent things however you like, there is no specific maximum line length.

 

<span style="color: #008080;">constant</span> <span style="color: #000000;">last_updated</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"March 24th, 2020"</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">elements_text</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">`

"""</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">last_updated</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">elements</span><span style="color: #0000FF;">),</span><span style="color: #000000;">elements</span><span style="color: #0000FF;">[$]})</span>

 

{{out}}

 

=={{header|PureBasic}}==

"nitrogen oxygen fluorine neon sodium magnesium " +

"aluminum silicon phosphorous sulfur chlorine argon " +

~"\nLast element: "+result$(nbf-1))

Input()

{{out}}

<pre>Last revision: 2020-11-11

 

=={{header|Python}}==

 

revision = "October 13th 2020"

if __name__ == "__main__":

report()

 

{{out}}

=={{header|Quackery}}==

 

[ stack ] is last-revision ( --> $ )

$ "6 Jun 2021" last-revision put

say "Number of elements: " elementcount echo cr

say "Last element: " finalelement echo$ cr

 

{{out}}

Not really sure I understand the point of this task. Seems to be load some list into memory and manipulate it somehow. Exceptionally boring to just read it in and then read it back out again. Perform some more interesting manipulations. Use < > quoting construct for literal string; unlimited (memory limited) characters, spaces don't matter, new-lines don't matter, blank lines don't matter.

 

%periodic<revision-date> = Date.new(2020,3,23);

%periodic<table> = |<

put 'Symbols for elements whose name starts with "P": ', %periodic<table>.grep( *.<name>.starts-with('P') )».<symbol>;

put "Elements with molecular weight between 20 & 40:\n ",%periodic<table>.grep( {+.<weight> ~~ Numeric and 20 < .<weight> < 40} )».<name>;

{{out}}

<pre>Revision date: 2020-03-23

 

Most modern REXXes have no practical limit for a clause length.

/*──────────────────────── ordered by their atomic number) in a list format. */

 

#= words(elements) /*the number of elements " " " */

say 'number of elements in the list: ' # /*show " " " " " " */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

The REXX version uses concatenation (also called abutment) to build the list.

/*──────────────────────── ordered by their atomic number) in a list format. */

 

#= words(elements) /*the number of elements " " " */

say 'number of elements in the list: ' # /*show " " " " " " */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

number of elements in the list: 118

the last element is: oganesson

</pre>

 

=={{header|Ruby}}==

hydrogen helium lithium beryllium

boron carbon nitrogen oxygen

number of elements: #{elements.size}

last element: #{elements.last}"

{{out}}

<pre>Last mutation 2021-08-30 17:14:16 +0200

 

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

 

val elements = "\

\last element:\t" ^ List.last lst ^ "\n")

 

{{out}}

<pre>revision date: 2021-02-25

=={{header|Tcl}}==

Using the neatly formatted table from other languages (can be reformatted easily using the non-standard utility column with option -t).

set elements {

hydrogen helium lithium beryllium

puts "Last modification time: $mtime"

puts "Number of elements: [llength $elements]"

{{out}}

<pre>Last modification time: 2021-05-10 16:11:50

are sufficient to extend it across as many lines as needed:

 

main() {

elements=(

printf 'Latest element: %s\n' "${elements[-1]}"

}

 

{{Out}}

=={{header|Wren}}==

{{libheader|Wren-pattern}}

 

var elementStr =

 

var p = Pattern.new("+1/s") // matches 1 or more whitespace characters

var elements = p.splitAll(elementStr) // get a list of elements

elementStr = elements.join(" ") // recombine using a single space as separator

System.print("Last updated : %(lastUpdate)")

System.print("Number of elements : %(elements.count)")

 

{{out}}

<pre>

Number of elements : 118

Last element : oganesson

(by default). To turn that into one string with one space between each item,

use: elements.concat(" ")

elements:=

#<<<"

#<<<

println("Revision date: ",revisionDate);

{{out}}

<pre>