PUBLIC

OK so I tried out OverloadedStrings and it basically went as bad as I expected. The documentation on `HsOverLit` is very promising: it points to the Note [Overloaded literal witnesses], which states:

Note [Overloaded literal witnesses]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

*Before* type checking, the HsExpr in an HsOverLit is the

name of the coercion function, 'fromInteger' or 'fromRational'.

So that sounds great, right? It sounds like just before renaming, I should be able to replace `HsLit _ (HsString _ fs)` with `HsOverLit _ (OverLit _ (HsIsString _ fs) unpack` with my own `unpack` function coming from my own package, and everything would work out. Unfortunately, this is not what happens: if I try getting this through the renamer, I get this error:

Failed to load interface for ‘Data.String’

no unit id matching ‘base’ was found

Can't find interface-file declaration for variable fromString

Probable cause: bug in .hi-boot file, or inconsistent .hi file

Use -ddump-if-trace to get an idea of which file caused the error

So even though I am specifying my own coercion function, it is still looking for `Data.String.fromString` which is not going to work, since I don’t have `base`. So either I am misunderstanding that Note, or it is simply out of date, but in either case, this isn’t going to be a viable route to going base-less.

Gergo

From: Erdi, Gergo
Sent: Tuesday, July 6, 2021 5:39 PM
To: Simon Peyton Jones <simonpj@microsoft.com>
Cc: GHC <ghc-devs@haskell.org>
Subject: RE: Marking ParsedModule fragments as non-user-originating

PUBLIC

Thanks Simon!

Of course, you’re right, it’s the renamer, not the typechecker – I didn’t really check, just saw that “it happens during `typecheckModule`.

I’ll look at the rebindable syntax stuff in detail, but at least for OverloadedStrings, I already know that the problem will be that ultimately they do go through the `String` type from `base`, and I need to use GHC baselessly. This is a problem for two reasons:

I can’t implement `IsString` for `MyString`, because `IsString` is in `base`
Even if I made my own fake `base` with a fake `IsString` class, there is nothing to put in the codomain of `fromString`: I *only* have `MyString`, not `String`. And renaming `MyString to `String` in my fake `base` is not going to cut it, since `String` is wired into GHC to be a type synonym for `[Char]` (which `MyString` is not).

I foresee similar problems for OverloadedLists :/

Thanks,

Gergo

From: Simon Peyton Jones <simonpj@microsoft.com>
Sent: Tuesday, July 6, 2021 5:08 PM
To: Erdi, Gergo <Gergo.Erdi@sc.com>
Cc: GHC <ghc-devs@haskell.org>
Subject: [External] RE: Marking ParsedModule fragments as non-user-originating

The typechecker now complains that the `ViewPatterns` language extension is not turned on

I think it’s the renamer:

rnPatAndThen mk p@(ViewPat _ expr pat)

= do { liftCps $ do { vp_flag <- xoptM LangExt.ViewPatterns

; checkErr vp_flag (badViewPat p) }

More generally, don’t you just want OverloadedStrings or OverloadedLists?

You might want to read Note [Handling overloaded and rebindable constructs] in GHC.Rename.Expr, and

Note [Rebindable syntax and HsExpansion] in GCH.Hs.Expr. These Notes describe how GHC already does something similar to what you want. Maybe you can use the same mechanism in your plugin.

Simon

From: ghc-devs <ghc-devs-bounces@haskell.org> On Behalf Of Erdi, Gergo via ghc-devs
Sent: 06 July 2021 09:08
To: ghc-devs@haskell.org
Subject: Marking ParsedModule fragments as non-user-originating

PUBLIC

Hi,

I’d like to hijack some syntax (like string literals or list patterns) for my own use, and I thought a low-tech way of doing that is to transform the ParsedModule before typechecking. For example, if I have a function `uncons :: Array a -> Maybe (a, Array a)`, I can rewrite the pattern `[x1, x2, x3]` into the view pattern `(uncons -> Just (x1, (uncons -> Just (x2, (uncons –> Just (x3, (uncons -> Nothing)))))))` and let the normal GHC type checker take over from here.

This is working for me so far, except for one problem: the typechecker now complains that the `ViewPatterns` language extension is not turned on. I would like to make the view patterns coming from my ParsedModule rewriter to be exempt from this check (but of course still require the `ViewPatterns` extension for user-originating code). Is there a way to do that? Or would I be better off checking for user-originating view patterns myself before the rewrite and then changing the `DynFlags` to always enable view patterns for typechecking?

Thanks,

Gergo