dhall-lsp-server

Release 1.1.3

[Last Documentation] Package maintainers For package maintainers and hackage trustees Candidates The Dhall language integration consists of the following parts: The "official" releases can be installed as follows: Note  The versions of vscode-dhall-lsp-server and dhall-lsp-server need not necessarily match: an older client version will simply not expose all commands available in the backend, while an older server might not implement all commands exposed in the UI. vscode-dhall-lsp-server dhall-lsp-server  For detailed instructions as well as instructions using cabal or nix, see dhall-haskell - README. To install dhall-lsp-server using stack: Diagnostics  Every time you save a Dhall file it is parsed and typechecked, and any errors are marked. You can hover over the offending code to see the error message; to see a detailed explanation in the case of type errors, click the Explain link in the hover box. Clickable imports  As long as the file parses successfully, all (local file and remote) imports will be underlined and clickable. Type on hover  You can hover over any part of the code and it will tell you the type of the subexpression at that point – if you highlight an identifier you see its type; if you highlight the -> in a function you will see the type of the entire function. This feature only works if the code passes the typechecker! Code completion  As you type you will be offered completions for: This is the only feature that works even when the file does not parse (or typecheck). Formatting and Linting  Right click and select "Format Document" to run the file through the Dhall formatter. The command "Lint and Format" can be selected via the Command Palette (Ctrl+Shift+P); this will run the linter over the file, removing unused let bindings and formatting the result. The default formatting behavior is to infer the character set used in the file (Unicode/ASCII operators). This can be overriden by using the Dhall LSP settings. For example in VS Code's settings.json: "vscode-dhall-lsp-server.character-set": "ascii" to always format using the ASCII character set "vscode-dhall-lsp-server.character-set": "unicode" to always format using the Unicode character set Annotate lets  Right-click the bound identifier in a let binding and select "Annotate Let binding with its type" to do exactly that. Freeze imports  Right-click an import statement and select "Freeze (refreeze) import" to add (or update) a semantic hash annotation to the import. You can also select "Freeze (refreeze) all imports" from the Command Palette to freeze all imports at once. Note that this feature behaves slightly differently from the dhall freeze command in that the hash annotations are inserted without re-formatting the rest of the code! dhall-lsp-server  See dhall-haskell - README for general development instructions. vscode-dhall-lsp-server Integration tests The dhall-lsp-server:tests testsuite depends on the dhall-lsp-server executable. Since stack isn't aware of this dependency, stack test dhall-lsp-server:tests may use an old executable version. Run these tests with to ensure that the executable is up-to-date.

Homepage Repository Hackage Download

Keywords
mit, program, unclassified, Propose Tags , Skip to Readme, Last Documentation, dhall-lsp-server-1.1.3.tar.gz, browse, Package description, Package maintainers, GabrielGonzalez, sjakobi, edit package information , vscode-language-dhall, vscode-dhall-lsp-server, LSP protocol, dhall-lsp-server, dhall-haskell, dhall-haskell README, dhall-haskell - README, configuration-language, dhall, haskell
License
MIT
Install
cabal install dhall-lsp-server-1.1.3

Documentation

dhall-haskell

You will probably want to read the language-agnostic README here:

This repository focuses on the Haskell bindings to Dhall and contains the following packages:

Navigate to each package's directory for their respective READMEs

Pre-built binaries

You can download pre-built binaries for Windows, OS X and Linux on the release page:

You can also install binaries for OS X using brew, like this:

$ brew install dhall-json

You can also install pre-built Linux binaries for master using Nix using Nix's channel mechanism by following the instructions at this link:

To install the Nix build products without a channel, configure your machine to use cache.dhall-lang.org, as described in the nix section and then visit one of the following links:

You can then click the "Help" button in the bottom right corner, which will show you a nix-env command that you can run to install the prebuilt executable.

If you have the jq command-line tool installed then you can do this in one command by running:

$ nix-env -i "$(curl -L https://hydra.dhall-lang.org/job/dhall-haskell/master/linux-dhall/latest/api/get-info | jq -r .outPath)"

These instructions also work for any pull request, too, by replacing master with the pull request number for any of the above URLs.

Pre-built containers

Prebuilt containers for the latest release available from Docker Hub:

... but if you want to obtain containers for bleeding-edge builds, you can download image archives for each package using the following URLs:

You can then load and run one of these archives like so:

$ NAME="dhall"

$ curl --location --remote-name "https://hydra.dhall-lang.org/job/dhall-haskell/master/image-${NAME}/latest/download/1/docker-image-${NAME}.tar.gz"

$ docker load < "docker-image-${NAME}.tar.gz"
...
Loaded image: dhall:vx95jiijmp2i07f5ynl8h6sllf34jggz

$ docker run --interactive --rm dhall:vx95jiijmp2i07f5ynl8h6sllf34jggz dhall <<< '2 + 2'
4

These instructions also work for any pull request, too, by replacing master with the pull request number for any of the above URLs.

Building from source

For all of the following instructions, make sure to first check out the dhall-lang submodule:

$ git submodule init
$ git submodule update

cabal

You can build all of the packages by running:

$ cabal new-build all

And each of them with cabal new-build <package-name>, for example:

$ cabal new-build dhall

... or you can run cabal new-build within each package directory.

nix

You will probably want to use the shared caches hosted at cache.dhall-lang.org and dhall.cachix.org when doing Nix development. This is not required, but this will save you a lot of time so that you don't have to build as many dependencies from scratch the first time.

If your operating system is NixOS then you can add the cache using these NixOS configuration options to access dhall packages from your declarative configuration file:

  nix = {
    binaryCaches = [
      "https://cache.nixos.org"
      "https://cache.dhall-lang.org"
      "https://dhall.cachix.org"
    ];

    binaryCachePublicKeys = [
      "cache.dhall-lang.org:I9/H18WHd60olG5GsIjolp7CtepSgJmM2CsO813VTmM="
      "dhall.cachix.org-1:8laGciue2JBwD49ICFtg+cIF8ddDaW7OFBjDb/dHEAo="
    ];
  };

If you are not using NixOS, then instead modify your /etc/nix/nix.conf file by adding the following options.

Using Nix 2.0 or later:

trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= cache.dhall-lang.org:I9/H18WHd60olG5GsIjolp7CtepSgJmM2CsO813VTmM= dhall.cachix.org-1:8laGciue2JBwD49ICFtg+cIF8ddDaW7OFBjDb/dHEAo=
substituters = https://cache.nixos.org https://cache.dhall-lang.org https://dhall.cachix.org

Using earlier Nix versions (i.e. Nix 1.*):

binary-cache-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= cache.dhall-lang.org:I9/H18WHd60olG5GsIjolp7CtepSgJmM2CsO813VTmM= dhall.cachix.org-1:8laGciue2JBwD49ICFtg+cIF8ddDaW7OFBjDb/dHEAo=
binary-caches = https://cache.nixos.org https://cache.dhall-lang.org https://dhall.cachix.org

Since many tests require HTTP access, you should also add this setting to your /etc/nix/nix.conf:

sandbox = false

You can build all of the packages by running:

$ nix-build

... or you can run nix-build within each package's respective directory to build just that one package.

You can install all of the packages by running:

$ nix-env --install --file default.nix

... or you can run the same command within each package's respective directory to install just that one package.

If you prefer installing the binaries locally in a nix shell environment instead, just run nix-shell in the top-level directory. This option provides additional flexibility with respect to overriding some of the default parameters (e.g. the compiler version), which makes it particularly useful for developers.

You can develop any package by navigating to that package's directory and running:

$ nix-shell
[nix-shell]$ cabal configure
[nix-shell]$ cabal build
[nix-shell]$ cabal test

... or you can add nix: True to your ~/.cabal/config file and then you can run the same cabal commands without an explicit nix-shell:

$ cabal configure
$ cabal build
$ cabal test

stack

You can build all of the packages with

$ stack build

And each of them with stack build <package-name>, for example:

$ stack build dhall-json

Profiling

Say you want to profile the dhall-to-json executable.

Build the containing package with profiling options:

$ stack build --profile --library-profiling dhall-json

Run the executable on your input. For example:

$ stack exec --profile --rts-options -p -- dhall-to-json <<< 'True && False'

This generates a dhall-to-json.prof file in your current directory.

Build the website

If you don't need to change the GHCJS code, then switch to the dhall-lang repository and follow these instructions instead:

If you do need to test changes to the GHCJS code (i.e. the ./dhall-try subdirectory) then stay within this repository, but edit the dhall/dhall-lang submodule to make the following change:

diff --git a/release.nix b/release.nix
--- a/dhall/dhall-lang/release.nix
+++ b/dhall/dhall-lang/release.nix
       let
         json = builtins.fromJSON (builtins.readFile ./nixops/dhall-haskell.json);
 
-        dhall-haskell =
-          pkgs.fetchFromGitHub {
-            owner = "dhall-lang";
-
-            repo = "dhall-haskell";
-
-            inherit (json) rev sha256 fetchSubmodules;
-          };
+        dhall-haskell = ../..;
 
       in
         import "${dhall-haskell}/default.nix";

... and then build the website by running:

$ nix build --file dhall/dhall-lang/release.nix website

... which will incorporate any GHCJS-related changes you make

Contributing

Read the following guide if you would like to contribute:

Stats

Dependent repositories
0
Total releases
23
Latest release
First release
Stars
895
Forks
205
Watchers
27
Contributors
126
Repository size
9.27 MB
SourceRank
12

Development practices

Source repo 2FA enabled
TEXT!
Package manager 2FA enabled
TEXT!
Is security responsive
TEXT!
Dependencies are managed
TEXT!
Issue-free release available
TEXT!
Succession plan available
TEXT!
Package manager 2FA enabled
TEXT!

The Tidelift Subscription provides access to a continuously curated stream of human-researched and maintainer-verified data on open source packages and their licenses, releases, vulnerabilities, and development practices.

Learn more →

Releases

1.0.1
1.0.10
1.0.11
1.0.12
1.0.13
1.0.14
1.0.15
1.0.16
1.0.17
1.0.0
See all 23 releases

Contributors

Gabriella Gonzalez Simon Jakobi EggBaconAndSpam German Robayo Javier Neira quasicomputational Ollie Charles Basile Henry Mann mit Hut Fabrizio Ferrai Felix Yan bosu Fintan Halpenny MarcosJLR Vanessa McHale Pi3r Julio amesgen Tristan de Cacqueray Greg Pfeil Tim Cuthbertson Profpatsch Markus Hauck Patrick Mylund Nielsen


See all contributors

Something wrong with this page? Make a suggestion

Export .ABOUT file for this package

Last synced: 2023-04-19 03:09:51 UTC

Login to resync this project