On 2/27/17, DavidLeibs david.leibs@gmail.com wrote:
I realize this is a few years old but I wanted to give an update on my quest for quasi-literals. I did a complete quasi-literal framework for Java when I moved over to Oracle Labs. It used the annotation compiler + a few tweeks to the scanner and parser. You could extend the name space of the quasi-literal and have inline SQL or APL. All the parsing, validation, and code rewriting happened at compile time. We proposed it to the Java Product guys and got ignored to death.
As to the characters I did backquote for simple quasi-literal Strings and used Oxford Brackets for the quasi-literals with a language namespace. <| ...|>. Back quote can be hard to see but is nice for String substitute.
At this point in time the language that does it most right is JavaScript. Thanks Mark Miller for all the hard work over the years!
Thanks David for following up this discussion.
I wonder if just going for JavaScript ES6 solution (back-ticks) would be the most straightforward thing to do?
--Hannes
https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Template_lite...
Syntax ----------
`string text`
`string text line 1 string text line 2`
`string text ${expression} string text`
tag `string text ${expression} string text`
Description ----------------
Template literals are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template literals can contain place holders. These are indicated by the Dollar sign and curly braces (${expression}). The expressions in the place holders and the text between them get passed to a function. The default function just concatenates the parts into a single string. If there is an expression preceding the template literal (tag here), the template string is called "tagged template literal". In that case, the tag expression (usually a function) gets called with the processed template literal, which you can then manipulate before outputting. To escape a back-tick in a template literal, put a backslash \ before the back-tick.
Hi Hannes,
On Mon, Feb 27, 2017 at 10:58 AM, H. Hirzel hannes.hirzel@gmail.com wrote:
On 2/27/17, DavidLeibs david.leibs@gmail.com wrote:
I realize this is a few years old but I wanted to give an update on my quest for quasi-literals. I did a complete quasi-literal framework for Java
when
I moved over to Oracle Labs. It used the annotation compiler + a few tweeks to the scanner and parser. You could extend the name space of the quasi-literal and have inline SQL or APL. All the parsing, validation,
and
code rewriting happened at compile time. We proposed it to the Java
Product
guys and got ignored to death.
As to the characters I did backquote for simple quasi-literal Strings and used Oxford Brackets for the quasi-literals with a language namespace. <| ...|>. Back quote can be hard to see but is nice for String substitute.
At this point in time the language that does it most right is JavaScript. Thanks Mark Miller for all the hard work over the years!
Thanks David for following up this discussion.
I wonder if just going for JavaScript ES6 solution (back-ticks) would be the most straightforward thing to do?
I did a quick hack in Squeak but didn't have time to finish is. I wrote some tests. Complex cases worked, small tricky cases broke the scanner.
MCHttpRepository location: 'http://source.squeak.org/inbox' user: '' password: ''
Compiler.quasiliteral-eem.280
[Derived from Compiler-nice.279, and renamed from the bogusly named Compiler.quasiquote-eem.248]
Add a quasi-literal form for "string interpolation", that allows convenient embedding of expressions within a format string, and provides a convenient way of embedding literal strings within an alternative literal string syntax whose string delimiter is different.
e.g. `hello [#cruel] world!` evaluates to 'hello cruel world'.
`S1[B1]...SN[BN]SN+1`
is equivalent to { 'S1'. [B1] value. ... 'SN'. [BN] value. 'SN+1' } concatenateQuasiLiteral where concatenateQuasiLiteral sends asString to each element and answers the concatenation of those elements.
however, single-statement blocks are inlined, so e.g. the above `hello [#cruel] world!` is compiled as { 'hello '. #cruel. ' world!' } concatenateQuasiLiteral
See e.g. Tests.quasiliteral-eem.296 for tests and examples.
Tests.quasiliteral-eem.296
Renamed from the bogus quasiquote to quasiliteral. Added Balazs' errors as failing tests.
--Hannes
https://developer.mozilla.org/en/docs/Web/JavaScript/ Reference/Template_literals
Syntax
`string text`
`string text line 1 string text line 2`
`string text ${expression} string text`
tag `string text ${expression} string text`
Description
Template literals are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template literals can contain place holders. These are indicated by the Dollar sign and curly braces (${expression}). The expressions in the place holders and the text between them get passed to a function. The default function just concatenates the parts into a single string. If there is an expression preceding the template literal (tag here), the template string is called "tagged template literal". In that case, the tag expression (usually a function) gets called with the processed template literal, which you can then manipulate before outputting. To escape a back-tick in a template literal, put a backslash \ before the back-tick.
On 2/27/17, Eliot Miranda eliot.miranda@gmail.com wrote:
Hello Eliot
Thank you for your quick-hack how an ES6 type template string addition could look like.
Which setup do I need to have a look at it?
I used http://files.squeak.org/6.0alpha/Squeak6.0alpha-16963-32bit/ And got the error which is attached.
Best wishes
--Hannes
Hi Hannes,
On Mon, Feb 27, 2017 at 10:58 AM, H. Hirzel hannes.hirzel@gmail.com wrote:
On 2/27/17, DavidLeibs david.leibs@gmail.com wrote:
I realize this is a few years old but I wanted to give an update on my quest for quasi-literals. I did a complete quasi-literal framework for Java
when
I moved over to Oracle Labs. It used the annotation compiler + a few tweeks to the scanner and parser. You could extend the name space of the quasi-literal and have inline SQL or APL. All the parsing, validation,
and
code rewriting happened at compile time. We proposed it to the Java
Product
guys and got ignored to death.
As to the characters I did backquote for simple quasi-literal Strings and used Oxford Brackets for the quasi-literals with a language namespace. <| ...|>. Back quote can be hard to see but is nice for String substitute.
At this point in time the language that does it most right is JavaScript. Thanks Mark Miller for all the hard work over the years!
Thanks David for following up this discussion.
I wonder if just going for JavaScript ES6 solution (back-ticks) would be the most straightforward thing to do?
I did a quick hack in Squeak but didn't have time to finish is. I wrote some tests. Complex cases worked, small tricky cases broke the scanner.
MCHttpRepository location: 'http://source.squeak.org/inbox' user: '' password: ''
Compiler.quasiliteral-eem.280
[Derived from Compiler-nice.279, and renamed from the bogusly named Compiler.quasiquote-eem.248]
Add a quasi-literal form for "string interpolation", that allows convenient embedding of expressions within a format string, and provides a convenient way of embedding literal strings within an alternative literal string syntax whose string delimiter is different.
e.g. `hello [#cruel] world!` evaluates to 'hello cruel world'.
`S1[B1]...SN[BN]SN+1`
is equivalent to { 'S1'. [B1] value. ... 'SN'. [BN] value. 'SN+1' } concatenateQuasiLiteral where concatenateQuasiLiteral sends asString to each element and answers the concatenation of those elements.
however, single-statement blocks are inlined, so e.g. the above `hello [#cruel] world!` is compiled as { 'hello '. #cruel. ' world!' } concatenateQuasiLiteral
See e.g. Tests.quasiliteral-eem.296 for tests and examples.
Tests.quasiliteral-eem.296
Renamed from the bogus quasiquote to quasiliteral. Added Balazs' errors as failing tests.
--Hannes
https://developer.mozilla.org/en/docs/Web/JavaScript/ Reference/Template_literals
Syntax
`string text`
`string text line 1 string text line 2`
`string text ${expression} string text`
tag `string text ${expression} string text`
Description
Template literals are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template literals can contain place holders. These are indicated by the Dollar sign and curly braces (${expression}). The expressions in the place holders and the text between them get passed to a function. The default function just concatenates the parts into a single string. If there is an expression preceding the template literal (tag here), the template string is called "tagged template literal". In that case, the tag expression (usually a function) gets called with the processed template literal, which you can then manipulate before outputting. To escape a back-tick in a template literal, put a backslash \ before the back-tick.
-- _,,,^..^,,,_ best, Eliot
squeak-dev@lists.squeakfoundation.org
-
Eliot Miranda -
H. Hirzel