Quoting constructs: Difference between revisions
BLC data embedding
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
(BLC data embedding) |
||
| (14 intermediate revisions by 6 users not shown) | |||
Line 147:
AB"C
</pre>
=={{header|Binary Lambda Calculus}}==
The ability to embed arbitrary binary data of any length with zero overhead is one of the defining features of BLC, in which a closed lambda term is parsed from the start of the programs, and then applied to the rest of the program, making the latter the quoted part. Even the simple hello world program, which in BLC is <code> Hello, world!</code> follows this pattern, with the initial space encoding the lambda term <code>\x.x</code> for the identity function.
The restriction is that only one string of data can be so embedded. If we need to embed more pieces, then we can concatenate self-delimiting descriptions, which incur some logarithmic overhead, e.g. by use of the Levenshtein encoding.
=={{header|BQN}}==
Line 179 ⟶ 184:
** Strings <syntaxhighlight lang="bqn">"Hello World"
"Quoted "" String"</syntaxhighlight> any sequence of characters including newlines can be put inside a string. Quotes are escaped by typing two quotes.
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <iostream>
#include <string>
#include <vector>
int main() {
// C++ uses double quotes for strings and single quotes for characters.
std::string simple_string = "This is a simple string";
char letter = 'A';
std::cout << simple_string << " " << letter << std::endl;
// C++ can implement multiline strings.
std::string multiline_string = R"(
An example of multi-line string.
Text formatting is preserved.
This is a raw string literal, introduced in C++ 11.)";
std::cout << multiline_string << std::endl;
// C++'s primitive data types: bool, char, double, float, int, long, short,
// can be used to to store data, for example,
const int block_length = 64;
std::cout << "block length = " << block_length << std::endl;
// Vectors of these data types are also possible, for example,
std::vector<double> state = { 1.0, 2.0, 3.0 };
}
</syntaxhighlight>
{{ out }}
<pre>
This is a simple string A
An example of multi-line string.
Text formatting is preserved.
This is a raw string literal, introduced in C++ 11.
block length = 64
</pre>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module test {
@Inject Console console;
void run() {
// characters are single quoted
Char ch = 'x';
console.print( $"ch={ch.quoted()}");
// strings are double quoted
String greeting = "Hello";
console.print( $"greeting={greeting.quoted()}");
// multi-line strings use '|' as a left column
// the start of the first line escapes the '|' to indicate the start of the multiline
// a trailing escape indicates that the current line continues without a linefeed
String lines = \|first line
|second line\
| continued
;
console.print($|lines=
|{lines}
);
// the $"..." is a template string, containing {expressions}
// the multi-line form of the template string uses $|
String name = "Bob";
String msg = $|{greeting} {name},
|Have a nice day!
|{ch}{ch}{ch}
;
console.print($|msg=
|{msg}
);
}
}
</syntaxhighlight>
{{out}}
<pre>
ch='x'
greeting="Hello"
lines=
first line
second line continued
msg=
Hello Bob,
Have a nice day!
xxx
</pre>
=={{header|FreeBASIC}}==
Line 362 ⟶ 456:
The use of an unbalanced right parenthesis as an escape character was inherited from APL. The double curly brace mechanism was a compromise between J's existing use of curly braces and visual conventions used in a variety of other languages.
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.List;
public final class QuotingConstructs {
public static void main(String[] args) {
// Java uses double quotes for strings and single quotes for characters.
String simple = "This is a simple string";
char letter = 'A';
// A Text Block is denoted by triple quotes.
String multiLineString = """
This is an example of multi-line string.
Text formatting is preserved.
Text blocks can be used for a multi-line string.
""";
System.out.println(multiLineString);
// Java's primitive data types: boolean, byte, char, double, float, int, long, short,
// can be used to to store data, for example,
final int blockLength = 64;
// Arrays or lists of these data types are possible, for example,
double[] state = new double[] { 1.0, 2.0, 3.0 };
// Custom data types can be stored in a record or a class, for example,
record Circle(int centreX, int centreY, double radius) {}
// A list of custom data types:
List<Circle> circles = List.of( new Circle(1, 2, 1.25), new Circle(-2, 3, 2.50) );
}
}
</syntaxhighlight>
{{ out }}
<pre>
This is an example of multi-line string.
Text formatting is preserved.
Text blocks can be used for a multi-line string.
</pre>
=={{header|jq}}==
Line 372 ⟶ 508:
</syntaxhighlight>Long JSON strings can be broken up into smaller JSON strings and concatenated
using the infix "+" operator, e.g. <syntaxhighlight lang="jq">
"This is not such a "
+ "long string after all."</syntaxhighlight>
"Raw data", such as character strings that are not expressed as JSON strings,
Line 561 ⟶ 697:
('a', 1, true)
(x: 1, y: 2)</pre>
=={{header|Perl}}==
Please consult the [[https://www.rosettacode.org/wiki/Literals/String#Perl String#Perl]] page that covers almost everything on syntax. The following are just some random supplements that mainly focus on usages.
<syntaxhighlight lang="perl" line># 20221202 Perl programming solution
use strict;
use warnings;
print <<`EXEC` # superfluous alternative to qx/ / and ` `
sleep 2; ls /etc/resolv.conf
EXEC
;
# only with quoted begin tag then you can have spaces in between
print <<END # so << 'END' or << "END" and semi-colon is always optional
Make sure that the end tag must be exactly the same as the begin tag.
END
; # the above wouldn't have worked had it been something like
# END␣ ␣ ␣ (with redundant trailing spaces)
print <<"HERE1", <<"HERE2" # it is also possible to stack heredocs
Hello from HERE1
HERE1
Hello from HERE2
HERE2
;
my $haystack = 'Santa says HoHoHo'; # a quoted pattern expanded before
my $needle = "\x48\x6F"; # the regex is interpreted
print "1) Found.\n" if $haystack =~ /$needle{3}/; # Matches Hooo
print "2) Found.\n" if $haystack =~ /($needle){3}/; # Do what you mean
# due to autoconversion, things may still work the same
{ use Benchmark; # under (usually overlooked) scalar interpolation
my ( $iterations, $x, $y ) = 1e7, rand, rand;
timethese( $iterations, { 'normal' => ' $x + $y',
'useless' => '"$x" + "$y"' } );
} # however in the 2nd case the boxing and unboxing are unnecessary
{ # the following illustrate some behaviors under array interpolation
my @Y_M_D = sub{$_[5]+1900,$_[4]+1,$_[3]}->(localtime(time));
local $\ = "\n";
print @Y_M_D; # YMD
print "@Y_M_D"; # Y M D
local $, = '-'; # output field separator
print @Y_M_D; # Y-M-D
print "@Y_M_D"; # Y M D
local $" = '_'; # interpolated list separator
print "@Y_M_D"; # Y_M_D
}</syntaxhighlight>
=={{header|Phix}}==
Line 604 ⟶ 789:
{{"John", "Smith"}, 52389, 97.25}
{} -- the 0-element sequence</syntaxhighlight>
=={{header|Quackery}}==
In Quackery, everything is code except when it is data. The objects it supports are operators ("primitives" or virtual op-codes), numbers (bigints) and nests (dynamic arrays that can contain operators, numbers, and nests, delimits by <code>[</code> and <code>]</code>). The behaviour of a number is to put its value on the data stack - in essence, numbers are self-quoting. However, in common with operators and nests, they can be explicitly quoted by preceding them with <code>'</code> (pronounced "quote"). The behaviour of <code>'</code> is to put the quackery object that follows it on the data stack rather than evaluate it, which is the default behaviour for all objects.
Any object can be given a name during compilation, using the word <code>is</code>, which is a "builder"; a word that is executed during compilation. The behaviour of <code>is</code> is to add the named object to the compiler's dictionary of named objects. So, for example, the number <code>12</code> could be declared as a constant called <code>dozen</code> with the Quackscript <code>12 is dozen</code>. However is it preferable to restrict the use of <code>is</code> to naming nests, (i.e. <code>[ 12 ] is dozen</code>) so that the Quackery decompiler <code>unbuild</code> can differentiate between the constant <code>dozen</code> and the literal <code>12</code>.
(Aside: The word <code>builds</code> is analogous to <code>is</code>, but creates new builders. The Quackery compiler is extensible, so new quoting constructs can be created as required.)
Other relevant builders include <code>hex</code>, which parses the whitespace delimited string following it as a hexadecimal number, <code>char</code>, which will embed a non-whitespace character (represented by a number), and <code>$</code>, which will embed a string (represented by a nest of characters).
The behaviour of <code>$</code> is to consider the first non-whitespace character following it as the string's delimiter, and treat everything following it as the string to be embedded until it encounters a second instance of the delimiter. Typically the delimiter for a string is <code>"</code>, but any non-whitespace character is acceptable, so the following are equivalent: <code>$ "Hello World!"</code>, <code>$ 'Hello World!'</code>, <code>$ ZHello World!Z</code>.
The builder <code>constant</code> evaluates the object that precedes it at runtime and embeds it as a literal during compilation, so <code>[ 10 18 ** ] constant</code> compiles as <code>1000000000000000000</code>.
Also relevant are look-up tables and ancillary stacks.
The word <code>table</code> is used to create look-up tables. As an example, the behaviour of the nest <code>[ table 2 3 5 7 11 13 17 19 23 29 ]</code> is to take a number, n, in the range <code>0</code> to <code>9</code> (inclusive) from the data stack and put the corresponding small prime number on the data stack. <code>table</code> is not limited to returning numbers, it will handle any Quackery object, so can be considered as a quoting construct.
The word <code>stack</code> is used to create ancillary stacks, which, like the data stack, are places to hold data. They are the Quackery analogue to variables, but can be pre-loaded with data much like tables. As an example, this stack is preloaded with two items; there is an empty nest <code>[ ]</code> on the top of the stack, and beneath that, the number <code>123</code>: <code>[ stack 123 [ ] ]</code>.
=={{header|Raku}}==
Line 893 ⟶ 1,098:
Here are some examples of all this.
<syntaxhighlight lang="
// simple string literal
| |||