Atomic terms of package set

Package set is a monad equipped with two capabilities:

1. Carry defined packages
2. Run IO actions

Package set is evaluated before shake runs. Use newPackage to add a new package, liftIO to run an IO action.

Add a package to package set

Add a list of packages into package set

Run package set into a set of packages

Throws exception as more then one packages with the same name are defined

A tagless final style DSL for constructing packages

PkgDSL version of newPackage

Example:

define $ package "nvfetcher-git" sourceGit "https://github.com/berberman/nvfetcher" fetchGitHub ("berberman", "nvfetcher")

Start chaining with the name of package to define

Attach version sources

Attach fetchers

A synonym of fetchGitHub and sourceGitHub

A synonym of fetchGitHub' and sourceGitHub

A synonym of fetchGitHub and sourceGitHubTag

A synonym of fetchGitHub' and sourceGitHubTag

A synonym of fetchPypi and sourcePypi

A synonym of fetchOpenVsx, sourceOpenVsx, and passthru extension's publisher with name

A synonym of fetchVscodeMarketplace, sourceVscodeMarketplace, and passthru extension's publisher with name

This package follows the latest github release

This package follows the a tag from github

Args are owner, repo, and nvchecker list options to find the target tag

This package follows the latest git commit

Arg is git url

Similar to sourceGit, but allows to specify branch

Args are git url and branch

This package follows the latest pypi release

Arg is pypi name

This package follows the version of an Aur package

Arg is package name in Aur

This package follows the version of an Arch Linux package

Arg is package name in Arch Linux repo

This package follows a pinned version

Arg is manual version

This package follows the version of a repology package

Args are repology project name and repo

This package follows a version extracted from web page

Args are web page url, regex, and list options

This package follows a version extracted from http header

Args are the url of the http request, regex, and list options

This package follows a version in Open VSX

Args are publisher and extension name

This package follows a version in Vscode Marketplace

Args are publisher and extension name

This package follows a version from a shell command

Arg is the command to run

This package is fetched from a github repo

Args are owner and repo

This package is fetched from a github repo

Similar to fetchGitHub, but allows a modifier to the fetcher. For example, you can enable fetch submodules like:

define $ package "qliveplayer" sourceGitHub (THMonster, QLivePlayer) fetchGitHub' (THMonster, QLivePlayer, fetchSubmodules .~ True)

This package is fetched from a file in github release

Args are owner, repo, and file name

This package is fetched from a file in github release

Args are owner, repo, and file name computed from version

This package is fetched from pypi

Arg is pypi name

This package is fetched from git

Arg is git url

This package is fetched from git

Similar to fetchGit, but allows a modifier to the fetcher. See fetchGitHub' for a concret example.

This package is fetched from url

Arg is a function which constructs the url from a version

This package is fetched from url

Args are a function which constructs the url from a version and a file name

This package is fetched from Open VSX

Args are publisher and extension name

This package is fetched from Vscode Marketplace

Args are publisher and extension name

This package is a tarball, fetched from url

Arg is a function which constructs the url from a version

Extract files from fetched package source

Run FetchRustGitDependencies given the path to Cargo.lock files

The lock files will be extracted as well.

Set NvcheckerOptions for a package, which can tweak the version number we obtain

An attrs set to pass through

Arg is a list of kv pairs

Pin a package

new version won't be checked if we have a stale version

Specify the date format for getting git commit date

Available only for git version source

Set always fetching regardless of the version changing

Simple HList

xs ++ ys, at type level

Project elements from Prod

Project optional elements from Prod

Constraint for producing error messages

A list of Member

A list of OptionalMember

Attach member x, with a function arg

Attach members xs, with a function argument arg

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

When used in conversions involving a newtype wrapper, make sure the newtype constructor is in scope.

This function is representation-polymorphic, but the RuntimeRep type argument is marked as Inferred, meaning that it is not available for visible type application. This means the typechecker will accept coerce @Int @Age 42.

Examples

>>> newtype TTL = TTL Int deriving (Eq, Ord, Show)
>>> newtype Age = Age Int deriving (Eq, Ord, Show)
>>> coerce (Age 42) :: TTL
TTL 42
>>> coerce (+ (1 :: Int)) (Age 42) :: TTL
TTL 43
>>> coerce (map (+ (1 :: Int))) [Age 42, Age 24] :: [TTL]
[TTL 43,TTL 25]

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

(.~) assigns a value to the target. It's the same thing as using (%~) with const:

l .~ x = l %~ const x

See set if you want a non-operator synonym.

Here it is used to change 2 fields of a 3-tuple:

>>> (0,0,0) & _1 .~ 1 & _3 .~ 3
(1,0,3)

(%~) applies a function to the target; an alternative explanation is that it is an inverse of sets, which turns a setter into an ordinary function. mapped %~ reverse is the same thing as fmap reverse.

See over if you want a non-operator synonym.

Negating the 1st element of a pair:

>>> (1,2) & _1 %~ negate
(-1,2)

Turning all Lefts in a list to upper case:

>>> (mapped._Left.mapped %~ toUpper) [Left "foo", Right "bar"]
[Left "FOO",Right "bar"]

(^.) applies a getter to a value; in other words, it gets a value out of a structure using a getter (which can be a lens, traversal, fold, etc.).

Getting 1st field of a tuple:

(^. _1) :: (a, b) -> a
(^. _1) = fst

When (^.) is used with a traversal, it combines all results using the Monoid instance for the resulting type. For instance, for lists it would be simple concatenation:

>>> ("str","ing") ^. each
"string"

The reason for this is that traversals use Applicative, and the Applicative instance for Const uses monoid concatenation to combine “effects” of Const.

A non-operator version of (^.) is called view, and it's a bit more general than (^.) (it works in MonadReader). If you need the general version, you can get it from microlens-mtl; otherwise there's view available in Lens.Micro.Extras.

(?~) is a version of (.~) that wraps the value into Just before setting.

l ?~ b = l .~ Just b

It can be useful in combination with at:

>>> Map.empty & at 3 ?~ x
fromList [(3,x)]