Changelog of @hackage/hnix 0.15.0

ChangeLog

(diff) 0.15.0

For support refere to: https://github.com/haskell-nix/hnix/issues/984

Partial log (for now):

Breaking:
- Nix.Expr.Shorthands:
  - inherit{,From}:
    - dropped second(/third) argument as irrelevant (report)
    - bindings to inherit changed type from complex [NKeyName] (which is for static & dynamic keys) to [VarName] (VarName is newtype of Text).
    - So examples of use now are: inherit ["a", "b"], inheritFrom (var "a") ["b", "c"]
  - mkAssert: fixed (report).
  - fx presedence between the operators:
```
(@@), (@.), (@./), ($==), ($!=), ($<), ($<=), ($>), ($>=), ($&&), ($||), ($->), ($//), ($+), ($-), ($*), ($/), ($++), (==>)
```
    Now these shorthands can be used without sectioning & so represent the Nix expressions one to one.
```
nix = "           a/b   //            c/def   //           <g>  <             def/d"
hask = mkRelPath "a/b" $// mkRelPath "c/def" $// mkEnvPath "g" $<  mkRelPath "def/d"
```
Additional
- Nix.Expr.Shorthands:
  - added:
    - emptySet
    - emptyList
    - mkOp{,2}
    - mk{,Named,Variadic,General}ParamSet
    - mkNeg - number negation.
    - @.<|> for Nix language s.x or y expession.
  - entered deprecation:
    - mkOper{,2} bacame mkOp{,2}.
    - mkBinop became mkOp2.
    - mkParaset supeceeded by mk{,Named{,Variadic},Variadic,General}ParamSet.
  - fixed:
    - mkAssert was creating with, now properly creates assert.

(diff) 0.14.0 (2021-07-08)

GHC 9.0 support.
HNix switched to pre-0.9 style of log (aka "no log"). We temporarily stopped producing log, choosing effectiveness over writing about it.
All changes seem trivial (from the inside). There is no changes in Nix.Expr.Shorthands module. Would there be difficulties in migration - please write to us - we would tackle & solve it togather.

A partial log:

Breaking:
- Nix.Effects:
  - rm pathExits in favour of doesPathExist (in Nix.Render: class MonadFile: doesPathExist)
- Nix.Var: was found being superflous (report), so reduced. use Control.Monad.Ref instead.
- Nix.Normal
  - rename opaque(,->Val), indicate that it is a literal.
- Nix.Thunk:
  - class MonadThunkId m => MonadThunk{,F} t m a:
    - rename query(M->){,F}
Additional:
- Nix.Utils:
  - added type TransformF
- Nix.Eval:
  - added fun:
    - evalContent
    - addMetaInfo
- Nix.Types.Assumption:
  - added instances:
    - Assumption: {Semigroup,Monoid,One}
- Nix.Type.Env:
  - added instances:
    - Env: {Semigroup,Monoid,One}
- Nix:
  - changed argument order:
    - nixEval:
```
-- was:
  => Maybe FilePath -> Transform g (m a) -> Alg g (m a) -> Fix g -> m a
-- became:
  => Transform g (m a) -> Alg g (m a) -> Maybe FilePath -> Fix g -> m a
```
- Nix.Normal
  - add thunkVal literal & use it where appropriate {deThunk, removeEffects}
- Nix.Thunk.Basic:
  - export deferred

(diff) 0.13.1 (2021-05-22)

(link) Nix.Parser: annotateLocation: Fix source location preservation.
(link) Require Cabal dependency relude >= 1.0: since imports & Cabal file got cleaned-up & that clean-up depends on relude reimports introduced in aforementioned version.
Refactors, reorganization in some modules, docs, clean-ups.

(diff) 0.13.0.1 (2021-05-11)

(link) Nix.Expr.Types: Fix CPP on Instances.TH.Lift import.

(diff) 0.13.0 (2021-05-10)

Breaking:

(link) (link) (link) Nix.Thunk: class MonadThunk t m a | t -> m, t -> a. Class was initially designed with Kleisli arrows (v -> m a) in mind, which where put to have the design open and inviting customization & integration. Those functional arguments are for custom implementation, so which in reality of the project were never used and HNax just "essentially" (simplifying, because pure was mixed with monadic binds to f) was passing pure into them (actually, f <=< pure). These Kliesli functors got arguments sorted properly and were moved to a MonadThunkF class and names gained *F. And MonadThunk now does only what is needed, for example force gets the thunk and computes it. All MonadThunk{,F} functions become with a classic Haskell arguments order, specialized, and got more straigh-forward to understand and use, and so now they tail recurse also.

Now, for example, instead of force t f use it as v <- force t f =<< force t, or f <=< force.

tl;dr: results:
```
class MonadThunkId m => MonadThunk t m a | t -> m, t -> a where

  thunkId  :: t -> ThunkId m

  thunk    :: m a -> m t

  queryM   :: m a -> t -> m a
  -- old became `queryMF`

  force    :: t -> m a
  -- old became `forceF`

  forceEff :: t -> m a
  -- old became `forceEffF`

  further  :: t -> m t
  -- old became `furtherF`


-- | Class of Kleisli functors for easiness of customized implementation developlemnt.
class MonadThunkF t m a | t -> m, t -> a where

  queryMF   :: (a   -> m r) -> m r -> t -> m r
  -- was :: t -> m r -> (a   -> m r) -> m r

  forceF    :: (a   -> m r) -> t   -> m r
  -- was :: t   -> (a   -> m r) -> m r

  forceEffF :: (a   -> m r) -> t   -> m r
  -- was :: t   -> (a   -> m r) -> m r

  furtherF  :: (m a -> m a) -> t   -> m t
  -- was :: t   -> (m a -> m a) -> m t
```
(link) (link) (link) (link) (link) Nix.Value.Monad: class MonadValue v m: instances became specialized, Kleisli versions unflipped the arguments of methods into a classical order and moved to the class MonadValueF. As a result, demand now gets optimized by GHC and also tail recurse. Please, use f =<< demand t, or just use demandF, while demandF in fact just kleisli =<< demand t.
```
class MonadValue v m where

  demand :: v       ->         m v
  -- old became `demandF`

  inform :: v -> m v
  -- old became `informF`


class MonadValueF v m where

  demandF :: (v -> m r) -> v -> m r
  -- was :: v -> (v -> m r) -> m r

  informF :: (m v -> m v) -> v -> m v
  -- was :: v -> (m v -> m v) -> m v
```
(link) Nix.Normal: normalizeValue removed first functional argument that was passing the function that did the thunk forcing. Now function provides the thunk forcing. Now to normalize simply use normalizeValue v. Old implementation now is normalizeValueF.
(link) Nix.Value.Equal: valueEqM: freed from RankNTypes: forall t f m ..

(link) Nix.Strings: all hacky* functions replaced with lawful implemetations, because of that all functions become lawful - dropped the principled suffix from functions:

Nix.String:

hackyGetStringNoContext          ->
     getStringNoContext
hackyStringIgnoreContext         ->
     stringIgnoreContext
hackyMakeNixStringWithoutContext ->
     makeNixStringWithoutContext

principledMempty        -> mempty
principledStringMempty  -> mempty
principledStringMConcat -> mconcat
principledStringMappend -> mappend

principledGetContext                        ->
          getContext
principledMakeNixString                     ->
          makeNixString
principledIntercalateNixStrin               ->
          intercalateNixString
principledGetStringNoContext                ->
          getStringNoContext
principledStringIgnoreContext               ->
          stringIgnoreContext
principledMakeNixStringWithoutContext       ->
          makeNixStringWithoutContext
principledMakeNixStringWithSingletonContext ->
          makeNixStringWithSingletonContext
principledModifyNixContents                 ->
          modifyNixContents

(link):

Data type: MonadFix1T t m: Nix.Standard -> Nix.Utils.Fix1

Children found their parents:

Binary   NAtom :: Nix.Expr.Types -> Nix.Atoms
FromJSON NAtom :: Nix.Expr.Types -> Nix.Atoms
ToJSON   NAtom :: Nix.Expr.Types -> Nix.Atoms

Eq1 (NValueF p m)     :: Nix.Value.Equal -> Nix.Value

Eq1 (NValue' t f m a) :: Nix.Value.Equal -> Nix.Value 

HasCitations m v (NValue' t f m a) :: Nix.Pretty -> Nix.Cited
HasCitations m v (NValue  t f m)   :: Nix.Pretty -> Nix.Cited

when
  (package hashable >= 1.3.1) -- gained instance
  $ Hashable1 NonEmpty:: Nix.Expr.Types -> Void -- please use upstreamed instance

-- | Was upstreamed, released in `ref-tf >= 0.5`.
MonadAtomicRef   (ST s) :: Nix.Standard -> Void

MonadAtomicRef   (Fix1T t m) :: Nix.Standard -> Nix.Utils.Fix1
MonadRef         (Fix1T t m) :: Nix.Standard -> Nix.Utils.Fix1
MonadEnv         (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadExec        (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadHttp        (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadInstantiate (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadIntrospect  (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadPaths       (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadPutStr      (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadStore       (Fix1T t m) :: Nix.Standard -> Nix.Effects
MonadFile        (Fix1T t m) :: Nix.Standard -> Nix.Render

MonadEnv         (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadExec        (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadHttp        (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadInstantiate (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadIntrospect  (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadPaths       (Fix1 t)    :: Nix.Standard -> Nix.Effects
MonadPutStr      (Fix1 t)    :: Nix.Standard -> Nix.Effects

(link) Nix.Value: nvSet{,',P}: got unflipped, now accept source position argument before the value.
(link) Nix.Pretty: mkNixDoc: got unflipped.
(link) Nix.Value: Data constructor for NValue' t f m a changed (NValue -> NValue').
(link) Nix.Parser: Parser: Data type was equivalent to Either, so became a type synonim for Either.
(link) Nix.Thunk.Basic: instance MonadThunk (NThunkF m v) m v: queryM: implementation no longer blocks the thunk resource it only reads from.
(link): Migrated (String -> Text):
- Nix.Value: {NValueF, nvBuiltin{,'}, builtin{,2,3}, describeValue}
- Nix.Eval: MonadNixEval
- Nix.Render.Frame: render{Expr,Value}
- Nix.Type: TVar
- Nix.Thunk: ThunkLoop
- Nix.Exec: {nvBuiltinP, nixInstantiateExpr, exec}
- Nix.Effects:
  - class:
    - MonadExec: exec'
    - MonadEnv: getEnvVar
    - MonadInstantiate: instatiateExpr
  - parseStoreResult
- Nix.Effects.Derivation: renderSymbolic
- Nix.Lint: {NTypeF, symerr}

Additional:
- (link) cabal.project: freed from the cryptohash-sha512 override, Hackage trustees made a revision.
- (link) To be more approachable for user understanding, the thunk representation in outputs changed from "<CYCLE>" -> "<expr>".
- (link) The Nix evaluation cycle representation changed "<CYCLE>" -> "<cycle>".
- (link) Nix.Expr.Types: added hacky implementation of liftTyped for instance Lift (Fix NExprF).
- (link) Nix.Builtins: derivation primOp internal code always fully evaluated, so GHC now always ships only fully compiled version in the bytecode.
- (link): Project switched to prelude relude.
- A bunch of other stuff that is not user-facing.

(diff) 0.12.0 (2021-01-05)

Disclaimer: Current derivationStrict primOp implementation and so every evaluation of a derivation into a store path currently relies on the hnix-store-remote, which for those operations relies on the running nix-daemon, and so operations use/produce effects into the /nix/store. Be cautious - it is effectful.
Introduction:
- New module Nix.Effects.Derivation.
- Operations on derivations:
  - old got principled implementations.
  - also new operations got introduced.
- Implementation of the derivationStrict primOp.
Breaking:
- (link) Nix.Effects: class MonadStore got principled implementation.
  - addPath' got principled into addToStore.
  - toFile_ got principled into addTextToStore'.
  - For help & easy migration you may use addPath & toFile_ addTextToStore standalone functions in the module.
- (link) Nix.Effects.Basic: defaultDerivationStrict got reimplemented & moved into Nix.Effects.Derivation.
- (link) Nix.Standard: instance for MonadStore (Fix1T t m) got principled accoding to class MonadStore changes.
- (link) Nix.Fresh.Basic: instance for MonadStore (StdIdT m) got principled.
Additional:
- (link) New module Nix.Effects.Derivation: HNix(0.12.0):Nix.Effects.Derivation documentation.
- (link) Nix.Convert: Principled NVPath -> NixString coercion.
  - In a form of principled instance FromValue NixString m (NValue' t f m (NValue t f m)).
- (link) Nix.String: Allow custom computations inside string contexts.
  - By providing runWithStringContext{T,}' methods into the API.
- (link) Includded support for new base16-bytestring, which advertices 2x-4x speed increase of its operations.
- (link) Nix.Effects: addPath & toFile_ standalone functions got principled implementation through the internal use of the new MonadStore type class implementation.
- (link) Nix.Effects: added addTextToStore, parseStoreResult implementations.
- (link) Nix.Effects: added type synonyms {RecursiveFlag, RepairFlag, StorePathName, FilePathFilter, StorePathSet}.
- (link) Nix.Exec: Fixed the rendering of internal Frames.
  - Which is an internal mechanism of a project to passing around messages with their context, still to be used internally).
- (link) HNix / Nix: The library now also uses hnix-store-remote.
- (link) cabal.project: project uses cryptohash-sha512 override, the hnix-store-core requires it from hnix and uses that override also. Detailed info. We promise to attend to this issue, probably by migrating to cryptonite in the nearest releases.

Future note: The HNix is a big project. During the initial development and currently the API for simplicity exposes allmost all functions, types, etc. Big open API means a big effort to create/maintain a quite noisy changelog and you parsing through it, and also creates a frequent requirements to mark releases as major and bother you due to some type changes in some parts that may not be used or applicable to be public API.

This year the most gracious API clean-up would happen, we would check and keep open what Hackage projects are using from the API, and the other parts would be open on the request by a way of rapid minor releases. That clean-up is also a work toward splitting the project into several packages some time in the future (split would be into something like Expressions, Evaluation, Executable, Extra), which migration also would be done most thoughful and graceful as possible, with as much easiness and automation provided for migration downstream as possible. If all goes as planned - all downstream would need to do is to get and run our script that would migrate our old map of module imports to new ones, and maybe manually add those newly formed packages into .cabal description.

If it is possible, please, try to switch & use the higher-level API functions where it is applicable. Thank you.

(diff) 0.11.1 (2020-12-09)

Additional:
- (link) Nix.Builtins: isString fixed - It used to return True for values coercible to string like derivations and paths. It only accepts string values now.
- (link) Nix.Builtins: substring fixed - Negative lengths used to capture an empty string. Now they capture the whole rmeainder of the string.
- (link) Nix.Effects: pathExists fixed - Now also works with directories.
- (link) Nix.Parser: -> is now properly right-associative (was non-associative).
- (link) Nix.Parser: Nix assert parser (nixAssert function) now accepts top-level Nix format also (which means also accepts all kinds of statements), before that it accepted only regular Nix expressions.
- (link) Nix.Render: renderLocation now also shows/handles location of errors in raw strings.

(diff) 0.11.0 (2020-11-02)

Breaking:
- (link) Deleted incorrect instance Generic1 NKeyName from module Nix.Expr.Types.
- (link) Parentheses now are properly included in the location annotation for Nix expressions, change of nixParens in module Nix.Parser essentially results in the change of all module nix* function results, essentially making results of the whole module more proper.
Additional:
- (link) Fix QQ Text lifting error: work around of GHC#12596 "can't find interface-file declaration".
- (link) Fix comments inclusion into location annotations, by using pre-whitespace position for source end locations.

(diff) 0.10.1 (2020-09-13)

Additional:
- (link) {Binding, NExpr, NExprF, NKeyName} gained Ord1 instances.
  - These instances were required by downstream projects to be able to use newer HNix.
- (link) CLI gained --long-version option for gathering a detailed debug information.
  - Currently, reports Git commit and its date.
  - (link) Currently does not work in case of use of the nix-build, in which case simply returns UNKNOWN placeholder.

(diff) 0.10.0 (2020-09-12)

Breaking:
- (link) Removed NExpr {FromJSON, ToJSON} instances.
  - This also removed the JSON output feature for unevaluated expression trees.
Additional:
- (link) CLI gained --version option.
- Dependencies:
  - (link) Requires last major data-fix (0.3).
  - (link) Requires last major prettyprinter (1.7).

(diff) 0.9.1 (2020-07-13)

Additional:
- REPL:
  - Better tab completion.
  - Accepting multi-line input.
  - Support for passing evaluated expression result of hnix --eval -E. to REPL as an input variable.
  - Support for loading .hnixrc from the current directory.
- Reporting of builtins.nixVersion bumped from 2.0 to 2.3.
- Dependencies:
  - Freed from: {interpolate, contravariant, semigroups, generic-random, tasty-quickcheck}.
  - Requires last major repline (0.4).

(diff) 0.9.0 (2020-06-15)

Breaking:
- Removed instances due to migration to haskeline 0.8:
  - instance MonadException m => MonadException(StateT(HashMap FilePath NExprLoc) m).
  - instance MonadException m => MonadException(Fix1T StandardTF m).
- Dependencies:
  - Requires last major haskeline (0.8).
Additional:
- Library: Official support for GHC 8.4 - 8.10.
- Executable complies only under GHC 8.10.
Changelog started. Previous release was 0.8.0.

HNix uses PVP Versioning.