Parsing broken on quasi quotes

[s9gf4ult]

for example, if I enter something like this

func = do 
    r <- withPG $ \con -> query con [sql|
select codes.user_id, aps.client_id
from authorization_codes as codes inner join applications as aps on codes.application_id = aps.id
where codes.access_token = ? and (codes.expires > now() or codes.expires is null)|]
                             [token]
    doSomething -- Indentation broken from this line with "parser error" message
    doMore

quasi quotes must be considered as strings, but they are considered as usual Haskell code. Maybe you can suggest how to solve it? I hope it is not very hard to solve this.

[s9gf4ult]

bump

[gracjan]

True. This should not be that hard:

• mark opening bracket as generic string
• mark closing bracket as generic string
• fontify as string or maybe something special

[s9gf4ult]

Yes, but how? I am not familiar with Emacs's parsing stuff and especially how and where it used in haskell-mode

[gracjan]

You should look at haskell-basic-syntactic-keywords in haskell-font-lock.el and understand what is going on there with double-quoted strings and single-quoted character literals. That is the hard part.

Quasi-quotes are basically string literals so you need to put "|" char class on opening bracket and on the closing bracket.

(Note additional issues with multiline. If you get the single line case working then we can convert it to multiline case later).

Relevant documentation starts about here: https://www.gnu.org/software/emacs/manual/html_node/elisp/Syntax-Class-Table.html

[s9gf4ult]

But operator || becomes string starter in this case.

String must be started at pattern, matching to regexp \[[a-zA-Z]*\| and ended at string |]. Is there such posibility?

[gracjan]

More exactly the char [ should be marked as generic string and then the last ']' should be also marked as generic string.

The char | does not change its meaning. The syntax code | means generic string and it is given to brackets. Sorry for the confusion.

(Note: some quasiquotes like e, d, t are actually Haskell so it might be good to use paired delimiters $ syntax class).

[s9gf4ult]

If I understand you correctly, you propose make Emacs consider any symbols between [ and ] as generic string. This means that usual Haskell lists like

[1,2,3]

and list comprehensions like

[(i,j) | i <- [1,2], j <- [1..4]]

become "strings" also, which is unacceptable.

[gracjan]

@s9gf4ult: This is not at all what I propose. Please have a look at documentation for variable font-lock-syntactic-keywords so that you understand how emacs puts syntactic properties on characters in a buffer.

[geraldus]

@gracjan this looks irrelevant.

[gracjan]

haskell-indentation-mode still does not handle quasiquotes