Correctly treat errors as a nested list in mkTyConHType.

This prevents no errors (list of empty lists) to be treated as an error
condition (since the list is not empty).

Don't mix up the i and dc_i variables.

Add support for multiple-constructor datatypes with fields.

This is the naïve implementation that will not try to use the same
storage space for fields from different constructors, so it might
quickly become inefficient with bigger datatypes. For simple types like
the Maybe type, this should be fine.

The support is not quite working yet, for some reason these new types
are not marked as representable. This is cause because the type
substitution in mkTyConHType does not work for some reason, so the field
type of the Just constructor in (for example) a Maybe Bool type stays
"a" instead of "Bool".

Add stringToVHDLExpr function.

Add datacon_index function to find a datacon in a type.

Make casesimpl support multiple-alt cases with fields.

Merge branch 'master' of git://github.com/christiaanb/clash

* 'master' of git://github.com/christiaanb/clash:
  Do not be overzealous with inlining results of polymorphic functions
  Do not function extract functions that still have free type variables
  Add setup file
  Fix cabal file to reflect temp bug fixes
  Temporarily disable "inlinenonrepresult" transformation, and apply eta-expansion transformation to all expressions
  Rename cλash dir to clash so it behaves well within the ghc build tree
  update cabal file to upload to hackage
  Remove defunct makeVHDLStrings function, messes with haddock
  Update reducer to use new integer types
  Reflect moving TFVec and TFP Integers into clash in sourcefiles related to builtin types
  Update package dependencies
  Move TFVec and TFP integers (Signed, Unsiged and Index) into clash

Do not be overzealous with inlining results of polymorphic functions

Do not function extract functions that still have free type variables

Add setup file

Fix cabal file to reflect temp bug fixes

Temporarily disable "inlinenonrepresult" transformation, and apply eta-expansion transformation to all expressions

Rename cλash dir to clash so it behaves well within the ghc build tree

update cabal file to upload to hackage

Remove defunct makeVHDLStrings function, messes with haddock

Update reducer to use new integer types

Reflect moving TFVec and TFP Integers into clash in sourcefiles related to builtin types

Update package dependencies

Move TFVec and TFP integers (Signed, Unsiged and Index) into clash

Also simplify top level binder scrutinees.

Previously, if the scrutinee was a variable reference, it would not be
simplified, skipping top level binders as scrutinees. Now only local
variable references are skipped.

Add a new "section" for type-class transformations.

Improve listBindings output.

Reorder transformations to match my thesis.

Also add or correct some comments.

Move a part of β-reduction to application propagation.

Make debug output controllable with a top-level "constant".

Add traceIf function for conditional tracing.

Move the application of "everywhere" to dotransforms.

Since every transformation is now applied "everywhere", we don't need to
specify this for every transform. This allows us to change the
application order in the future.

Remove some commented out code.

s/normalise/normalize/

Don't inline non representable results with free type variables.

argprop should ensure that these variables get removed eventually
anyway.

Improve error message in mkSelCase.

Replace fst with a lambda in a map.

Cλash doesn't like mapping the fst builtin yet, so avoid that for now.

Forbid inlinenonrepresult to inline dictionaries.

Remove two debug traces.

Rewrite fromInteger and literal generation.

Literals are less of a hack now and should work more reliably.

No longer treat tfp ints as builtin types.

This makes tfp ints non-representable, breaking their use as literal
arguments to fromIntegerT for now.

Add genCoreArgs wrapper to VHDL.Generate.

Move tfp_to_int from VHDLTools to CoreTools.

Add getFullString function to get a qualified name.

Add non-representable result inlining transformation.

Add case of known constructor simplification.

Allow normalized functions to have a non-representable result.

An extra boolean argument to getNormalized / isNormalizeable switches
this behaviour when needed (which is never currently).

This commit also removes the unused isNormalizeable'.

Add allM and anyM functions.

Split off selector case creation code into CoreTools.

Make top level inlining handle non-representable results gracefully.

Since it does not know (nor care) if the function result is
representable, it now uses splitNormalizedNonRep and checks if the
result is a Var afterwards.

Fix typo in error message.

Add variant of splitNormalized for non-representable expressions.

Switch order of clauses in retvalsimpl to match thesis.

Update comment for return value simplification.

Fix let binding inlining in some cases.

Let binding inlining was not working properly when an to-be-inlined
binding used another to-be-inlined binding and they were inlined in the
wrong order (the result would be a reference to a no longer existing
binding).

Turn letderecursification into let recursification again.

Since we can't completely derecursify everything, just make our lives
easy by making everything recursive.

Revert "Make inlinebind work for non-recursive lets."

This reverts commit 077fe523188b85aff82569232acecfc9dbb082cb.

Conflicts:

cλash/CLasH/Normalize/NormalizeTools.hs

Slightly move the "after normalization" debug output.

This should ensure it is always printed. Previously, it seems it was printed
only when the final state from the monad was accessed, not when the
value was used (which caused problems if the value caused an error
further on).

Compilefix debug output.

Update reducer to latest design (that runs at 159 MHz)

Add time dependency to cabal package

Show number of transformations per function.

Keep (and show) a count of applied transformations.

Merge lambdasimpl, letsimpl and simplres into retvalsimpl transformation.

This makes these transformations like described in my thesis.

Show the current transformation context in the debug output.

Derive Show for CoreContext.

Add is_let predicate.

Log the time needed for compilation.

Only apply eta expansion to expressions at the top level.

Derive Eq for CoreContext.

Add LambdaBody to CoreContext.

Only inline top level functions that are completely applied.

Partial function applications will be inlined in their entirety to make
them fully applied first.

Inline all simple top level functions, not just compiler-generated ones.

The checking for compiler generated functions wasn't watertight, so
let's just don't check at all. There is no risk for loops with
funextract anymore, since we only inline functions applied in let
bindings now.

Only inline dictionaries that are likely to be resolvable.

Only inline top level functions that are applied in a let binding.

This should limit the amount of inlinings that happen a bit, make sure
inlining is only done in later stages of inlining and only when it
actually helps to prevent useless components. This should help to
prevent loops with inlinedict, since dictionary arguments should never
be inlined anymore.

Add LetBody and LetBinding to the CoreContext.

Remove notappargs, which is unused now.

Let eta expansion use the passed context instead of using notappargs.

Add AppFirst and AddSecond to CoreContext.

Also let subeverywhere set those contexts when appropriate.

Pass the context in which an expression occurs to each transformation.

Currently, the only context supported is "Other" and contexts are only
passed around and not yet used anywhere.

add fromRangedWord function, and add error message to genVarArgs

Merge branch 'master' of git.stderr.nl/matthijs/master-project/cλash

Conflicts:
cλash/CLasH/Normalize.hs
cλash/CLasH/Normalize/NormalizeTools.hs

Fix gencopy' to use proper vhdl names

Add "init" to list of builtin function within NormalizeTools

Move built_in names to different list within NormalizeTools

Fix zipWith template to work with partially applied functions, add support for boolean negation, and update error message of classopresolution transformation

Don't inline == and /=.

This is a hack to prevent problems caused by the derived Eq instances.
This is not a real solution, though.

Restructure the top level inlining transformation.

It now checks to see if the original (non-normalized) body is already
simple and only resorts to normalizing if the original body isn't simple
already. This should speed things up a bit, also because inlining the
normalized body probably needs some extra cleanups.

Don't resolve class operations that are builtin functions.

We already have a fixed VHDL translation for these, and usually the
actual implementation is not translateable (for example, the derived Eq
instances translate dataconstructors to Int#'s and use GHC.Prim.==# to
compare them).

Use the list of builtin functions for inlining.

Previously a small, fixed list of functions was used for inlining. Now
we use the full list of builtin functions instead.

Slightly improve normalization debug output.

When tracing individual transformations, their before and after outputs
are now always directly after each other.

Fix casesimpl and caseremove wrt scrutinee binders.

Previously, they would not check if the scrutinee binder was used,
resulting in it being removed or incorrectly used in some cases.

Put a list of builtin functions in VHDL.Constants

This will allow normalization to use this list, without creating
circular dependencies by using VHDL.Generate.globalNameTable.

Let classoperationresolution handle partially inlined dictionaries.

Previously, if a dictionary argument was not yet an application of a
dataconstructor (e.g., completely inlined) but an application of a
polymorphic top level binder (e.g., $fsomething), then it would complain
about mismatching types.

Make listBindings return IO () instead of IO [()].

The previous type caused ghci to print an extra list of units after the
regular output, while it simple ignores the single tuple now.

Show classes in listBindings output.

Show uniques in listBindings output.

Add class operation resolution transformation.

This transformation enables user-defined type classes.

Add dictionary inlining transformation.

Let inlinetoplevel use getNormalized_maybe.

This makes the transformation slightly simpler and prepares it for
inlining dictionaries next.

Let getNormalized return Nothing on non-normalizeable functions.

Add variant of isNormalizeable that operates in the TranslatorSession.

Add variant of isRepr that operates in the TranslatorSession.

Add getNormalized_maybe that does not fail if a binder was not found.

Remove getBinding and use getGlobalBind instead.