Add compileWithTyCtx.

Add support for (>=>).

Add GNUmakefile rule : tag.

Fix Mono{Foldable,Functor} and {Semi,Is}Sequence constraints.

Cleaner to support the constraints
in the various data types' Proj_TyConC
instead of the constraints'.
For instance, this avoids to require the IO TyConst
when using MonoFunctor.

Add withContext.

Fix stack clean.

Rename grammar rules, prefixing them with g_.

Rename Term_Name -> TeName

Add IsString instances.

Fix time&space explosion of GHC's typechecker.

Add Lib.{Bounded,Enum,Ratio,Rational,Real,Semigroup}.

Fix comment typo.

Fix lexeme to progress over indented lines.

Renaming Constants -> TyConsts.

Cosmetic cleanup of GHC flags.

Add GNUmakefile.

Cosmetic cleanup.

Fix Inj_ConstP -> Inj_TyConstP.

Use AllowAmbiguousTypes to avoid using Proxy.

Cosmetic cleanup.

Fix empty and eoi.

Backtrack (try) the grammar only when necessary to get better error messages.

Gather type declarations and infix declarations.

Reduce compile time of tests with -O0 -fmax-simplifier-iterations=0.

Split into symantic{,-grammar,-lib}.

Bump version.

Renames.

Polish doc.

Add optional.

Add stack.yaml.

Update doc.

Fix Lib.Ord : Ordering.

Fix module including.

Use more TypeApplications.

Remove Alternative uses in grammars.

Fix Lib.Text.

Move libraries in Lib.

Add Gram_Term.

Add Parsing.Grammar.

Fix comment typo.

Add Compiling.Alternative.

Renaming textI_app* to textI*.

Clarify names, and add commentaries (bis).

Clarify names, and add commentaries.

Add Compiling.Show.

Add Parsing.Token.

Add Compiling.Sequences.

Add Compiling.NonNull.

Add Compiling.MonoFoldable.

Add Typing.Family and Compiling.MonoFunctor.

Add tests for Compiling.

Fix lambda application.

Use GHC-8.0.1's TypeInType to handle kinds better, and migrate Compiling.

Add Compiling, Interpreting and Transforming.

Simplify the Constraint projection

Revamp the type system.

This is definitively much more correct, simple and powerful this way:
kinds are now properly handled,
type constraints capture is now quite neat,
and usable type variables should be possible.

Though the current code may seem obvious and natural
for the task at hand, it required
first to know that this was indeed this task that has to be done…

Indeed I was previously much more focused on the symantics part,
but this happened when I decided to put a day or two
to check if type inferencing would indeed be possible with the previous type system,
I rapidly convinced myself that I couldn't handle type variables as required,
so I then put aside the previous type system to work anew
from the main (mono)type of Top,
which also appears in Write You a Haskell:

data Type
 =   TVar TVar
 |   TCon String
 |   TArr Type Type

As in the previous type system,
I first tried to have Type indexing an Haskell type (h)
by using the usual GADTs way,
which was surprisingly possible for every kind:
once I realized this could be done through Proxy
(this definitively is a very important type
to compute with GHC's type system),
and found that the type application could be handled
with a type family, which could effectively let me build types
from an AST, the type family's result just stays abstract,
and GADTs put constraints in scope with it in them.

The Index GADT of GLambda was my inspiration to handle type constants
through a type list of them, and thus drop the previous approach
which was indexing types (and not type constants)
and required much more code.

I then tried to have Type always well-formed through GADTs,
my first attempt was (stupidly) to only check the arity,
then I realized it was not enough and introduced a Kind type.

At this point I was able to kindcheck an AST of a type,
but failed to replicate the previous approach to capture a Constraint,
hopefully I then tried (without much hope it would work)
to do the "obvious thing" (since this is what GHC does),
that is to add a type constraint kind into Kind,
which proved itself quite rewarding.
Surprisingly I've quickly found that introducing UnProxy
enables to capture Constraints which need to work on abstract types,
like (Eq a) to prove (Eq (Maybe a)).

Work ahead is to try to update the previous approach
to build expressions with symantics.
Then later to try again type inferencing.

Cheers :-)

factorizing Type1_From ast Type0

polish code

fix Num requiring Integer

Type1_From instances

polish code, Foldable

Repr_Dup helpers

Foldable, Num

explore parsing of partially applied functions

polish names

Eq, Ord

polish names

MonoFunctor

revamp Repr/*

Integer, Integral, Num

Map

fix (->) by removing inline/val/lazy

IO, Monoid, Foldable, Text

Monad

remove old files

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init

init