After the first report, I’ve done various tasks, so let’s go over them one by one:

The first task was to implement the part of GHC proposal #448 Modern Scoped Type Variables about extension shuffling.

Short description: `ScopedTypeVariables`

extension does three different things. Firstly, it enables pattern signatures:

```
not (a :: Bool) = Prelude.not a
-- ↑ disallowed without ScopedTypeVariables
```

The second thing the extension does is add type variables from a type class and an instance head into the scope of its methods:

```
class C a where
f :: a -> a
f x = (x :: a) -- `a` scoped from the class head
-- and
instance C a => C (Identity a) where
f = coerce @(a -> a) f
-- ↑ `a` scoped from the instance head
```

And the third one is about scoping type variables from `forall`

everywhere:

```
id :: forall a . a -> a
id x = (x :: a)
f = Left @a :: forall a . a -> Either a ()
-- and so on
```

With proposal #448 these would be three different extensions: `PatternSignatures`

, `MethodTypeVariables`

, and `ExtendedForAllScope`

. `ScopedTypeVariables`

will simply enable them all. I did this split up in !10385.

The proposal in the section I am describing also declares a new extension `ImplicitForAll`

that allows you to control if you want to have implicit forall’s and a new warning - `-Wpattern-signature-binds`

that warns about type variable binding in pattern signature, but currently, they are under discussion. I have a merge request with `-Wpattern-signature-binds`

implemented, but I’m not sure that it will be merged into master: !10585.

Next, I did a couple of small documentation improvements: !10327 and !10366.

The first of them just describe `ImplicitParams`

extension behavior more precisely. GHC must always use the most nested binding of the implicit variable:

```
f = let ?foo = 5 in let ?foo = 6 in ?foo -- `f` must be 6. If it isn't, then GHC has a bug
data D where
MkD :: (?foo :: Int) -> D
g MkD MkD = ?foo -- here ?foo must come from the second matching
```

If GHC violates this behavior (I hope it will not anyway), you can point to the new section of the GHC User’s Guide in an issue description.

The second documentation improvement mentions `nubOrd`

from the `containers`

package as a better alternative to the `nub`

function from the `base`

in `nub`

's haddock.

After that, I addressed issue #22558. Here GHC allows haddock comments, that should be rejected:

```
module
-- | Bad comment for the module
T17544_kw where
data Foo -- | Bad comment for MkFoo
where MkFoo :: Foo
newtype Bar -- | Bad comment for MkBar
where MkBar :: () -> Bar
class Cls a
-- | Bad comment for clsmethod
where
clsmethod :: a
```

I reanimated two merge requests that in conjunction solve this issue: !9476 and !9477. The first of them adds tokens `module`

, `signature`

, `data`

, `newtype`

, `class`

, `where`

into Haskell AST and updates all the places that use updated constructors. The second one applies these tokens in `GHC.Parser.PostProcess.Haddock`

to reject malformed comments. These merge requests a ready, but no one wants to review them (x1).

Then in discussion under my merge requests with extension shuffling was found an issue with `-Wterm-variable-capture`

: #23434. This warning notifies you if you have an implicitly bound type variable that has the same name as a term-level variable, but it ignores the fact that the type variable may be bound in the type class head

```
k = 12
class C k a where
type AT a :: k -> Type
-- ↑ `k` bound in the class head, but
-- `-Wterm-variable-capture` produces
-- warning
```

I fixed this issue in the merge request !10548, but no one wants to review it (x2).

And at the end, I solved an old issue !16635. Here the problem is in a scoping distinction between term level and type level:

```
{-# LANGUAGE ScopedTypeVariables #-}
-- f :: [forall b . Either b ()]
f = [Right @a @() () :: forall a. Either a ()] -- works
type F = '[Right @a @() () :: forall a. Either a ()] -- doesn't work
-- ↑ not in scope
```

The complication is that we can’t elaborate this type into Core. In term level GHC at desugaring phase inserts lambda with a type variable, so introduces binder for `a`

```
f = [(\@a -> Right @a @() ()) :: forall a . Either a ()]
```

But in types we can’t do the same, because we have no lambda in types

```
type F = '[(/\ a . Right @a @() ()) :: forall a. Either a ()]
-- ↑ not in haskell :(
```

We want to unify term level and type level, but we can’t elaborate this type with the current GHC. The partial solution is to move the error from the renaming phase to the elaboration phase, and that is what I did in the merge request !10560. It is also ready for review, but no one wants to do that (x3).

And that’s all for this week! GHC team, please, review my patches.