This is needed by the lenses to be added later.

See frege/compiler/types/Symbols.fr

As a first step to decomposing the sum-record SymbolT, SymT was isolated
to an independent data type.

Some parts of code were deliberately rewritten into refutable case
analyses so that compiler warnings are triggered.

The field accessors of SymbolT were replaced with lenses.

Partial functions were deliberately introduced to trigger compilation
warnings where certain constructor is implicitly assumed (for example,
an unsafe conversion `SymbolT g -> SymD g` is inserted to a piece of
code which accesses `flds`, which exists only on `SymD`.)

Lots of redundant unsafeToSymVs and its friends were removed.

by tightening the types of parameters

- removed redundant pattern from `sref`
- changed the type of `overSig` to take `SymV Global`

By changing the type of the local function `rbSymT` to return `SymT`

by tightening the parameter types

by tightening the types of parameters

by tightening the parameters

allvars was changed from monadic value to a plain function because it
doesn't change nay state.

Some functions in other modules had their parameters tightened.

Ported from Haskell's profunctors and lens

Ad-hoc isSym? functions were replaced with the prisms.

SymVal is a sum type of SymV and SymD.

Because it can only take SymD and SymV.

Non-exhaustive case analysis was done on a parameter 'msym :: Symbol'
but that was done just before returning a value.
So it was moved out of the function to the caller site, removing the
need to match on Symbol.

Also the parameter was changed to 'mpos :: Position' because 'mkanno'
was only interested in 'pos' field.

The symbols must be SymCs because they are looked up by QNames which
belong to SymC.supers.

SymbolT.V is always matched by the second pattern because of
'Lens.has SymbolT.typ msym', rendering the third one redundant.

Under that assumption, the non-exhaustive case was rewritten so that it
becomes noop on uninterested cases.

SymMeth is a new data type which is a sum of SymL and SymV.
SymI.env was renamed to SymI.meth and can now accept SymL and SymV only.

The following functions now take SymMeth instead of Symbol. This change
is considered safe because they threw runtime errors when receiving
other than SymL or SymV.

- frege.compiler.Classes.tcInstMethod
- frege.compiler.gen.java.VarCode.varCode
- frege.compiler.passes.Easy.checkDepth

SymbolT.env' which is a generalization of .env and .meth is added and
uses of SymbolT.env are replaced with SymbolT.env' where applicable.

All of the call sites assume that.

strictReturn now uses SymVal (i.e. SymV|SymD) instead of Symbol,
removing uses of partial functions.

The call sites assumed (VName g.thisPack "main") pointed to a SymV (as
it should be). It is now guaranteed by the type.

Its partialness remains same.

I'm pretty sure that (Let.env :: [QName]) points to SymVs only.

I think Vbl.name refers to a SymV.

Only SymV were pushed into genEnv. Partial functions at some of the call
sites were eliminated.

AFAICS almost all of the calling sites assume the return value is SymT.

MethodCall.methCode assumed its Symbol parameter to be SymV.
The other related functions, which could handle / were called with SymV
only, were modified as well.

The partialness couldn't removed. It was moved to the call site.

It seems pointless to crash the compiler when a symbol can't have a
documentation (i.e. it's a SymL). Instead it is ignored.

If a SymbolT's name is Local, it is converted to SymV.

It is safe but it can't be proved by the type system until QName, the
sum type, is split just like SymbolT.

For now, the non-exclusive case analysis is replaced by a private unsafe
conversion to supress unwanted compilation warnings.

The same reasoning as symWarning. It is pointless to crash the compiler
if a symbol is known not to be able to have a doc.

A new local function 'mapEnvSymV' that traverses Symbol.env was added to
solve the issue.

The same reasoning as symWarning. It is pointless to crash the compiler
if a symbol is known not to be able to have an env-like thing.

The same reasoning as symWarning. It is pointless to crash the compiler
if a symbol is known not to be able to have an env-like thing.

In transFunDcl, non-SymVals are just ignored.
In ordInfix, non-SymVals will be treated as errors. (later)

SymC.env was renamed to SymC.meth and can now accept SymL and SymV only.

The lens SymbolT.env was removed because SymT is the only type that has
an 'env'.

lowerKindSpecialClasses has a partial function that cannot be avoided.
The error case is an internal error (caused by bad frege.Prelude.List).

A redundant guard which introduced that error was removed.

Instead of crashing, erroneous cases are simply treated as un-matched
cases.

Instead of crashing, erroneous cases are simply treated as un-matched
cases.

All SymMeths in SymC.meth should have been resolved to SymV in this
phase (at least that's how I understand the code).

An error here, if any, is an internal error, and is reported as a pure
error to help find a bug in the compiler.

Some functions in Global assumes certain propeties of Symbols. Those
assumptions should be correct unless something goes very wrong.

An error here, if any, is an internal error, and is reported as a pure
error to help find a bug in the compiler.

Since only SymMeth (i.e. SymV or SymL) can be a member of SymC.meth or
SymI.meth, if 'sym' is not SymMeth, it is an error.

A new error message was added to report it instead of just crashing.

A part of MethodCall.nativeCall uses unsafePartialView a lot. The reason
is that it was written by myself as a prototype and is not polished yet.

Instead of crashing, erroneous cases are simply treated as un-matched
cases.

'allfuns' now contain SymVs only. If non SymVs are in an env of a
Symbol, they are just now ignored.

Some of the other functions had their types changed in order to reflect
that change.

Instead of crashing, erroneous cases are simply treated as un-matched
cases.

being "private" crashes fregedoc (but not fregec).

optimizations from now on

Particularly unsafePartialView (defined in f.c.common.Lens) is no longer
used anywhere.

Added simple getters to SymbolT to be used instead of 'view'ing a
'Lens'. In Haskell, 'view' can have significant overhead than simple
pattern matching.

The existing lenses were given a leading underscore, like the prisms.

We don't use 'review', so Traversal is enough.
Well, we do use 'is', but 'has' can be used for the purpose.

Prism depends on Profunctor. In Haskell, the "profunctor" is a huge
package. If, in some day, we port it to Frege, the compiler depending on
it may be a problem.

The same refactoring as done to SymbolT.

Now all uses of 'view's were replaced by simple getters.

This contributes to a big reduction of performance penalty.

A redundant pattern match was removed.

Unused partial function
The new type SymVal and its member fromSymbol serves the same purpose.

On invalid data constructor, 'updVis' behaves as 'id' instead of an
error, just like 'over' in lens does.

An error case in symInfo was eliminated. Related functions were altered
to reflect this change. Most notably Global.GenSt.symi8 now have (SymVal
Global) instead of Symbol as keys.

A new error message was added to lowerKindSpecialClasses. It didn't make
sense to pass SymL to lowerKindAbstractFun because it would eventually
put into symi8 but never referenced because symInfo were never called
with SymL.

Removed unwanted diffs introduced by a series of modifications