Strings as lists of characters?

[triska]

Currently, I get:

[A,B] = "ab".
No results

For comparison, see how for example Scryer, Tau and Trealla Prolog interpret the string "ab":

?- [A,B] = "ab".
   A = a, B = b.

These Prolog systems treat double-quoted strings as lists of characters, which makes them extremely convenient to reason about, using common predicates over lists and also DCGs.

Note that internally, strings can still be represented extremely compactly (using UTF-8 encoding internally). Prolog code "sees" such strings as lists, even though they are much more compactly represented internally.

Do you have any plans to likewise make strings accessible as lists of characters? It would render your system extremely useful.

[w-henderson]

I'm honoured that you found my project and looked into it so deeply! Yes, that's a great suggestion and certainly one I will look into implementing when I get a moment. Thank you!

[triska]

Awesome, thank you so much! Your system, especially with this feature, will make for an awesome Prolog teaching environment that is easy to try.

Also, please consider attending the Scryer Prolog meetup to meet many people interested in Prolog there:

https://hsd-pbsa.de/veranstaltung/scryer-prolog-meetup-2025/

The agenda will be posted soon.

[w-henderson]

I had a go at implementing this in #29, thanks for the suggestion! It should (🤞) now work as you specify (and as the other implementations do it).

[triska]

Awesome, thank you a lot!

Currently, I get:

write_canonical("abc").
No results

Expected output:

'.'(a,'.'(b,'.'(c,[]))) 

[triska]

Implementing this may affect several more parts of your system. To make the implementation correct and robust in all places, consider limiting the amount of places that even "see" the (purely internally) different representations of lists. Spreading the distinction throughout many parts of the code risks getting more cases wrong, and is also tedious to implement.

That is, consider not distinguishing cases between "lists" and "strings", but instead for example "What is the functor? What are the arguments? etc."

For both lists and strings, the principal functor is '.'/2 or []/0, and if you base your case distinctions on this building block, then more code will be automatically correct, no matter how strings are internally implemented.

See also mthom/scryer-prolog#3054.

This approach also keeps the door far more open for future extension of this idea to partial strings, which can also be represented very compactly, and the implementation will affect the fewer places in your code the more paper over internal representation differences.

[Jean-Luc-Picard-2021]

Its not yet working, try this Prolog text:

test("The quick brown fox jumps over the lazy dog").

Try these queries, the 2nd query has A and B not instantiated:

test([A|B]).
A: T, B: he quick brown fox jumps over the lazy dog (0.9ms)

test(X), X = [A|B].
X: The quick brown fox jumps over the lazy dog, A: _13, B: _14 (1.0ms)

Compare with Scryer Playground, A and B are instantiated:

test(X), X = [A|B].
X = "The quick brown fox jumps over the lazy dog", 
A = 'T', B = "he quick brown fox jumps over the lazy dog".

Sorry if I did some premature testing, but the change was already
pushed to your playground and was therefore already online.

[w-henderson]

You're right, this doesn't work. I'm going to redesign this implementation as @triska suggested when I have time and I'll fix it then.