Quoting constructs: Difference between revisions

 

Pretty much every programming language has some form of quoting construct to allow embedding of data in a program, be it literal strings, numeric data or some combination thereof.

Note: This is primarily for quoting constructs for data to be "embedded" in some way into a program. If there is some special format for external data, it may be mentioned but that isn't the focus of this task.

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

 

MyString: db "Hello World!",0 ;a null-terminated string

 

 

=={{header|Go}}==

 

import (

}

fmt.Println(os.Expand("There are ${NUMBER} quoting ${TYPES} in Go.", mapper))

 

{{out}}

There are 3 quoting constructs in Go.

There are 3 quoting constructs in Go.

</pre>

 

of such values. Such data can be included in a jq program wherever an expression is allowed, but

in a jq program, consecutive JSON values must be specified using "," as a separator, as shown in this snippet:

"A string", 1, {"a":0}, [1,2,[3]]

;

"Raw data", such as character strings that are not expressed as JSON strings,

cannot be included in jq programs textually but must be "imported" in some manner, e.g. from

 

=={{header|Julia}}==

 

* String literals are delimited by double quotes or triple double quotes:

julia> str = "Hello, world.\n"

"Hello, world.\n"

a newline"""

"Contains \"quote\" characters and \na newline"

 

* Both single and triple quoted strings are may contain interpolated values. Triple-quoted strings are also dedented to the level of the least-indented line. This is useful for defining strings within code that is indented. For example:

julia> str = """

Hello,

"""

" Hello,\n world.\n"

* Julia allows interpolation into string literals using $:

julia> "$greet, $whom.\n"

"Hello, world.\n"

* The shortest complete expression after the $ is taken as the expression whose value is to be interpolated into the string. Thus, you can interpolate any expression into a string using parentheses:

julia> "1 + 2 = $(1 + 2)"

"1 + 2 = 3"

* Julia reserves the single quote ' for character literals, not for strings:

julia> 'π'

'π': Unicode U+03C0 (category Ll: Letter, lowercase)

* Julia requires commands sent to functions such as run() be surrounded by backticks. Such expressions create a Cmd object, which is used for running a child process from Julia:

julia> mycommand = `echo hello`

`echo hello`

julia> run(mycommand);

hello

* Julia uses the colon : in metaprogramming for quoting symbols and other code:

julia> a = :+

:+

julia> eval(c)

5

 

=={{header|Nim}}==

Tuples literals are defined as a list of values between parentheses. Field names may be specified by preceding a value by the name followed by a colon.<br/>

 

echo "A simple string."

echo "A simple string including tabulation special character \\t: \t."

# Tuples.

echo ('a', 1, true) # Tuple without explicit field names.

 

{{out}}

('a', 1, true)

(x: 1, y: 2)</pre>

 

=={{header|Phix}}==

Back-ticks and triple-quotes are used for multi-line strings, without backslash interpretation, eg

 

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

one

three

`</span>

 

or (entirely equivalent, except the following can contain back-ticks which the above cannot, and vice versa for triple quotes)

 

<span style="color: #008080;">constant</span> <span style="color: #000000;">t123</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""

one

three

"""</span>

 

Both are also equivalent to the top double-quote one-liner. Note that a single leading '\n' is automatically stripped.<br>

You can also declare hexadecimal strings, eg

 

<span style="color: #000000;">x</span><span style="color: #008000;">"1 2 34 5678_AbC"</span> <span style="color: #000080;font-style:italic;">-- same as {0x01, 0x02, 0x34, 0x56, 0x78, 0xAB, 0x0C}

-- note however it displays as {1,2,52,86,120,171,12}

-- whereas x"414243" displays as "ABC" (as all chars)</span>

 

Literal [http://phix.x10.mx/docs/html/sequences.htm sequences] are represented with curly braces, and can be nested to any depth, eg

{1, 2, {3, 3, 3}, 4, {5, {6}}}

{{"John", "Smith"}, 52389, 97.25}

 

=={{header|Raku}}==

 

 

Raku has a whole quoting specific sub-language built in called Q. Q changes the parsing rules inside the quoting structure and allows extremely fine control over how the enclosed data is parsed. Every quoting construct in Raku is some form of a Q syntactic structure, using adverbs to fine tune the desired behavior, though many of the most commonly used have some form of "shortcut" syntax for quick and easy use. Usually, when using an adverbial form, you may omit the Q: and just use the adverb.

 

The different types (or styles) of incorporating quoted constructs are a largely matter of style.

a= 'This is one method of including a '' (an apostrophe) within a string.'

b= "This is one method of including a ' (an apostrophe) within a string."

/*the variable L (with an */

/*intervening blank between each */

 

=={{header|Ring}}==

text = list(3)

 

see "quoted text:" + nl + str + nl + nl

next

{{out}}

text for quoting: <br>

====Characters====

Character literals are prefixed by a "$". Conceptionally, they are the elements of strings, although effectively only the codePoint is stored in strings. But when accessing a string element, instances of Character are used. Characters can be asked for being uppercase, lowercase, etc.

$Å

 

====Strings====

String literals are enclosed in single quotes. Conceptionally, they holde instances of Character as element, but actually the underlying storage representation is chosen to be space effective. Typically, underneath are classes like SingleByteString, TwoByteString and FourByteString, but this is transparent to the programmer. Strings can hold any Unicode character; UTF8 is only used when strings are exchanged with the external world (which is good, as it makes operations like stringLength much easier).

 

Traditional Smalltalk-80 does not support any escapes inside strings, which is inconvenient, occasionally.<br>Smalltalk/X supports an extended syntax for C-like strings:

{{works with|Smalltalk/X}}

and also embedded expressions:

 

====Arrays====

Literal arrays are written as #(...), where the elements are space separated; each literal array element can be any type of literal again, optionally omitting the '#'-character:

Here, the third element is a fraction, followed by the symbol #'foo', two arrays, a character, another string, the boolean true, a byteArray and the boolean false.

 

====ByteArrays====

A dense collection of byte valued integers is written as #[..]. Conceptionally, they are arrays of integer values in the range 0..255, but use only one byte per element of storage. They are typically used for bulk storage such as bitmap images, or when exchanging such with external functions.

 

====Symbols====

These are like symbol atoms in Lisp/Scheme, written as #'...' (i.e. like a string with hash prefix).

If the characters do not contain special characters or are of the form allowed for a message selector, the quotes can be omitted. Symbols are often used as key in dictionaries, especially for message selectors and global/namespace name bindings. They can be quickly compared using "==", which is. a pointer compare (identity) instead of "=" which is compares the contents (equality).

#'foo bar baz'

#foo. " same as #'foo' "

#'++'

#++ " same as #'++' "

 

====Blocks====

Blocks thus represent a piece of code which can be stored in an instance variable, passed as argument or returned from a method.

<br>Block syntax is very compact:

or for a block with arguments:

Blocks are one of the fundamental building blocks of Smalltalk (no pun here), as the language (Compiler) does not specify any syntax for control structures. Control structures like if, while, etc. are all implemented as library functions, and defined eg. in the Boolean, Block or Collection classes.

<br>

If you have a block at hand, it can be evaluated by sending it a "value"message:

The most basic implementation of such a control structure is found in the Boolean subclasses True and False, which implement eg. "<tt>ifTrue:arg</tt>" and "<tt>ifFalse:</tt>". Here are those two as concrete example:

ifTrue: aBlock

^ aBlock value "I am true, so I evaluate the block"

in the False class:

ifTrue: aBlock

Thus, the expression <tt>"someBoolean ifTrue:[ 'hello print' ]"</tt> will either evaluate the lambda or not, depending on the someBoolean receiver.

Obviously, you can teach other objects on how to respond to "value" messages and then use them as if they where blocks.

====Inline Object====

{{works with|Smalltalk/X}}

foo: <someConstant>

bar: <someConstant>

Generates a literal constant instance of an anonymous class, with two instance vars: foo and bar.

The object is dumb in that it only provides getter and setter functions. These are used eg. when returning structured multiple values from a method.

Similar to byteArrays, there are dense arrays of ints, floats, doubles or bits (i.e. they use much less memory compared to regular arrays, which hold pointers to their elements). They are also perfect when calling out to C-language functions. The syntax is analogous to the Scheme language's syntax:

{{works with|Smalltalk/X}}

#u32( 1 2 3 ). " an array of unsigned int32s "

#u64( 1 2 3 ). " an array of unsigned int64s "

#f64( -1 2.0 3 ). " an array of float64s "

#b( 1 0 1 1 0 0 ). " an array of bits "

 

=={{header|Wren}}==

 

Here are some examples of all this.

 

// simple string literal

"""

System.print(r)

 

{{out}}

Single (") or dual ("") double-quotes can be included without problem.

</pre>

 

=={{header|zkl}}==

A #<<<" beginning tag prepends a " to the block.

For example:

text:=

"

A

";

 

is parsed as text:="\nA\n";