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