# NEXT # 0.4.1 * Add `MonadFail` instances for `LFreshMT` and `FreshMT` * Builds with GHC 8.10 # 0.4.0 * New binding specification type `Ignore`. Any two `Ignore T` terms will always be alpha-equivalent to each other, will be considered to contain no variables, and will not have any substitution apply beneath `Ignore`. Useful for attaching annotation terms to your AST. ```haskell import Text.Parsec.Pos (SourcePos) data Expr = ... | Lambda (Ignore SourcePos) (Bind (Name Expr) Expr) ``` As expected, any two `Lambda` expressions will be considered alpha-equivalent even if they differ in source position. Note that the `Ignore` will block operations on `Name a` for all `a`, which can be a little unexpected: ```haskell data Ty = TyVar (Name Ty) | TyArr Ty Ty instance Subst Ty Ty where ... data Expr = ... | Var (Name Expr) | Lambda (Ignore Ty) (Bind (Name Expr) Expr) instance Subst Ty Expr ``` Applying a substitution of a type for a free type variable to a `Lambda` will not descend into the `Ignore Ty`. Thanks Reed Mullanix (TOTWBF) for the new operation. * Fix an issue in substitution where traversal would not continue in an AST node for which `isvar` or `isCoerceVar` is defined to return non-`Nothing` but which had additional structure. For example, in a language with meta variables and explicit substitutions: ```haskell data Expr = ... -- normal variables that stand for expressions | Var (Name Expr) -- a meta variable occurrence and an explicit substitution -- of expressions to substitute in for the free variables | MetaVar (Name Meta) [(Name Expr, Expr)] -- a meta variable stands for an expression with some free term vars data Meta = MetaVar Expr -- substitution for a meta in an expression instance Subst Expr Meta where isCoerceVar (MetaVar u sub) = Just (SubstCoerce u (Just . applyExplicitSubst sub)) applyExplicitSubst :: [(Name Expr, Expr)] -> Meta -> Expr applyExplicitSubst s (MetaVar e) = substs s e ``` Given an expression `e1` defined as `MetaVar "u" [("x", 10)]`, we may want to substitute a `Meta ("x" + "x")` for `"u"` to get `10 + 10` (that is, we replace `"u"` by the expression `"x" + "x"` and immediately apply the substitution `10` for `"x"`). Now suppose we have an expression `e2` defined as `MetaVar "v" [("y", e1)]` (that is, an occurrence of meta var "v" together with a substitution of `e1` from above for `"y"`). If we again try to substitute `Meta ("x" + "x")` for `"u"` in `e2`, we would expect to get `MetaVar "v" [("y", 10 + 10)]` (that is, since "v" is not equal to "u", we leave the meta var alone, but substitute for any occurrences of "u" in the explicit substitution, so `e1` becomes `10 + 10` as before). The bug in previous versions of `unbound-generics` was that we would incorrectly leave `MetaVar "v" [("y", e1)]` unchanged as soon as we saw that `isCoerceVar (MetaVar "v" [("y", e1)])` returned `Just (SubstCoerce "u" ...)` where `"u" /= "v"`. Thanks Reed Mullanix (TOTWBF) for finding and fixing this issue. https://github.com/lambdageek/unbound-generics/issues/26 # 0.3.4 * Bump `containers` upper bound to support `0.6`. (GHC 8.6.1 support) Thanks Christiaan Baaij. # 0.3.3 * Bump `exceptions` upper bound to support `0.10.0` # 0.3.2 * Bump `deepseq >= 1.4.0.0` remove benchmark dependency on `deepseq-generics` * Tested with GHC 8.4.1 * Tested with GHC 8.2.2 * Compile with `-Wcompat` * Add `Semigroup` instances for all types that were previously `Monoid` instances * Added more examples to the [examples/ directory](https://github.com/lambdageek/unbound-generics/tree/master/examples) * Added "exceptions" dependency and `MonadThrow`, `MonadCatch`, `MonadMask` instances for `FreshMT` and `LFreshMT`. Thanks Alex McKenna. # 0.3.1 * Tested with GHC 8.0.1 * Removed `Generic b` constraint from `Subst b (Name a)` instance. # 0.3 * Change types of `open` and `close` to take `NthPatFind` and `NamePatFind` instead of generic patterns, update call sites. * Add newtype wrappers and Monoid instances for `NthPatFind` and `NamePatFind` * Change `isTerm` to return `All` instead of `Bool` # 0.2 * Incorporating some of the extras/oversights from [clash-lib Unbound.Generics.LocallyNameless.Extra](https://github.com/clash-lang/clash-compiler/blob/master/clash-lib/src/Unbound/Generics/LocallyNameless/Extra.hs) * Make `Embed` an instance of `Ord` * `NFData` instances (see below) * Re-implement `freshen'` and `gfreshen` using a free monad to give GHC a chance to inline it all away. This changes the type of `gfreshen`. Major version bump. * Expose `FFM`, `liftFFM` and `retractFFM` * Provide `NFData` instances for all the combinators. Depend on 'deepseq' * Start benchmarking some of the operations (particularly `unbind`). # 0.1.2.1 * Fix ghc-7.10 build. * Haddock cleanup. # 0.1.2 * Added `IsEmbed` typeclass * Depend on 'profunctors' * Changed `embed` and `unembed` to work over any `IsEmbed` type. * Added `Shift` type for shifting the scope of embedded terms out one level. # 0.1.1 * Added `isNullDisjointSet` function. * Implement a TH `makeClosedAlpha` splice for constructing trivial leaf instances. # 0.1 * Add `acompare` functiona and `acompare'` method to `Alpha` typeclass. (christiaanb) Handwritten `Alpha` instances will need to define this additional method now. Major version bump. # 0.0.3 * Add 'name2Integer' method (christiaanb) * Export internal type-directed `gaeq`, `gopen`, `gclose`, etc functions from `Unbound.Generics.LocallyNameless.Alpha`. Allows definitions like: instance Alpha Term where aeq' _ (Prim t1 _dk1) (Prim t2 _dk2) = t1 == t2 aeq' c t1 t2 = gaeq c (from t1) (from t2) # 0.0.2.1 * Unconditionally add ErrorT and ExceptT instances using transformers-compat (bergmark) # 0.0.2 * Add 'Rec' pattern and 'TRec' term combinators. * Alpha instance for '()' # 0.0.1 * Add 'lunbind2' function. * Doc updates. * Switch from 'HUnit' to 'Tasty' for testing. # 0.0.0.90 * Initial (re-)implementation effort.