cabal - Official upstream development repository for Cabal and cabal-install

  •        17

The canonical upstream repository is located at https://github.com/haskell/cabal. Prebuilt binary releases can be obtained from https://www.haskell.org/cabal/download.html. The cabal-install binary download for your platform should contain the cabal executable.

http://haskell.org/cabal
https://github.com/haskell/cabal

Tags
Implementation
License
Platform

   




Related Projects

hackage-server - Hackage-Server: A Haskell Package Repository

  •    Haskell

This is the hackage-server code. This is what powers http://hackage.haskell.org, and many other private hackage instances. The master branch is suitable for general usage. Specific policy and documentation for the central hackage instance exists in the central-server branch. ICU stands for "International Components for Unicode". The icu4c is a set of libraries that provide Unicode and Globalization support. The text-icu Haskell package uses the icu4c library to build.

hlint - Haskell source code suggestions

  •    Haskell

Installation follows the standard pattern of any Haskell library or program: type cabal update to update your local hackage database, then cabal install hlint to install HLint. Each hint says which file/line the hint relates to, how serious an issue it is, a description of the hint, what it found, and what you might want to replace it with. In the case of the first hint, it has suggested that instead of applying concat and map separately, it would be better to use the combination function concatMap.

heroku-buildpack-ghc - Deploy Haskell apps to Heroku

  •    Shell

This buildpack supports frameworks like Yesod, Snap, and Happstack with the latest stable GHC binaries. Putting Haskell web applications online should be easy, and now it is. Try it for yourself. The first deploy is slowest as the environment downloads and bootstraps. Subsequent deploys use cached binaries and cached cabal packages to go faster.

yst - create static websites from YAML data and string templates

  •    Haskell

yst is a tool for generating a static website by filling string templates with data taken from YAML or CSV text files or SQLite3 file based databases. This approach combines the speed, security, and ease of deployment of a static website with the flexibility and maintainability of a dynamic site that separates presentation and data. yst is written in Haskell. The easiest way to install yst is by using Haskell's cabal install tool. The best way to get this tool is to install the Haskell platform, which includes a complete installation of the GHC compiler and the cabal executable.

ghc-mod - Happy Haskell Hacking for editors. CI: https://gitlab.com/dxld/ghc-mod/pipelines

  •    Haskell

ghc-mod provides editors/IDEs with support for Haskell compiler features. It supports both Cabal and Stack based projects and integrations exist for Emacs, Vim, Atom, IntelliJ and VSCode. We provide two modes of operation for frontends: interactive and single shot mode. The former is accessed by calling $ ghc-mod legacy-interactive. This will sit and wait for you to type a command, exiting when an empty line is entered. Interactive mode is pretty much always faster than single shot mode, since it gives ghc-mod the ability to cache the compiler session between commands. On the other hand, it needs more memory because it keeps these things cached.


tryhaskell - Try Haskell

  •    Javascript

```$ cabal sandbox init$ cabal install --only-dependencies$ cabal build$ cabal sandbox hc-pkg hide monads-tf```Start tryhaskell, hosted at http://127.0.0.1:4001/```$ env PATH=./.cabal-sandbox/bin:$PATH \ GHC_PACKAGE_PATH=$(cabal sandbox hc-pkg list | grep '^/.*\.cabal-sandbox') \ ./dist/build/tryhaskell/tryhaskell```tryhaskell does not currently support any command line argumentsor configuration files.

cabal - Official upstream development repository for Cabal and cabal-install

  •    Haskell

Official upstream development repository for Cabal and cabal-install

haskell-language-server - Successor of ghcide & haskell-ide-engine. One IDE to rule them all.

  •    Haskell

Integration point for ghcide and haskell-ide-engine. One IDE to rule them all. Read the project's background.

hpack - hpack: An alternative format for Haskell packages

  •    Haskell

Hpack is a format for Haskell packages. It is a modern alternative to the Cabal package format and follows different design principles. By default Hpack uses YAML as surface syntax. With sol/hpack-dhall the Dhall configuration language can be used instead of YAML.

stgi - A user-centric visual STG implementation to help understand GHC/Haskell's execution model.

  •    Haskell

STGi is a visual STG implementation to help understand Haskell's execution model. If you want to have a quick look at the STG, here is what you need to get going. The program should build with both stack and cabal.

yi - The Haskell-Scriptable Editor

  •    Haskell

Yi is a collection of packages that serve as building blocks for making your very own text editor. Just running stack install yi or cabal install -j yi would be akin to unwrapping a box of lego and finding an assembled spaceship there. Note that this way, it will not be possible to use a custom configuration.

stackage - "Stable Hackage": vetted consistent packages from Hackage

  •    Shell

"Stable Hackage": creating a vetted set of packages from Hackage. This repository is for package authors and maintainers to get their packages into Stackage. If you simply want to use Stackage as an end user, please follow the instructions on https://www.stackage.org/. We strongly recommend using the Haskell tool stack for doing builds, which includes built-in Stackage support: stack .

miso - :ramen: A tasty Haskell front-end framework

  •    Haskell

Miso is a small "isomorphic" Haskell front-end framework for quickly building highly interactive single-page web applications. It features a virtual-dom, diffing / patching algorithm, attribute and property normalization, event delegation, event batching, SVG, Server-sent events, Websockets, type-safe servant-style routing and an extensible Subscription-based subsystem. Inspired by Elm, Redux and Bobril. Miso is pure by default, but side effects (like XHR) can be introduced into the system via the Effect data type. Miso makes heavy use of the GHCJS FFI and therefore has minimal dependencies. Miso can be considered a shallow embedded domain-specific language for modern web programming. To get started quickly building applications, we recommend using the stack or nix package managers. Obtaining GHCJS is required as a prerequisite. stack and nix make this process easy, if you're using cabal we assume you have obtained GHCJS by other means.

lsp - Haskell library for the Microsoft Language Server Protocol

  •    Haskell

Haskell library for the Microsoft Language Server Protocol. It currently implements all of the 3.15 specification. Try out the example tests in the lsp-test/example directory with cabal test. For more examples check the Wiki, or see this introductory blog post.

CABAL-Callback Balance C++ net framework

  •    C++

Cabal is a C++ framework that provides support for high prestation parallel processing network servers and clients. It doesn't provide a protocol, it just gives you the abstraction of data sending/receiving in real time or priority scheduling.

cubicaltt - Experimental implementation of Cubical Type Theory

  •    Haskell

For examples, including a demo ("examples/demo.ctt"), see the examples folder. For a summary of where to find the main results of the cubical type theory paper in the examples folder see "examples/summary.ctt". You can compile the project using either cabal, make, or stack.

syntastic - Syntax checking hacks for vim

  •    Vim

Syntastic is a syntax checking plugin for Vim created by Martin Grenfell. It runs files through external syntax checkers and displays any resulting errors to the user. This can be done on demand, or automatically as files are saved. If syntax errors are detected, the user is notified and is happy because they didn't have to compile their code or execute their script to find them. At the time of this writing, syntastic has checking plugins for ACPI Source Language, ActionScript, Ada, Ansible configurations, API Blueprint, AppleScript, AsciiDoc, Assembly languages, BEMHTML, Bro, Bourne shell, C, C++, C#, Cabal, Chef, CMake, CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dockerfile, Dust, Elixir, Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell, Haxe, Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, Julia, LESS, Lex, Limbo, LISP, LLVM intermediate language, Lua, Markdown, MATLAB, Mercury, NASM, Nix, Objective-C, Objective-C++, OCaml, Perl, Perl 6, Perl POD, PHP, gettext Portable Object, OS X and iOS property lists, Pug (formerly Jade), Puppet, Python, QML, R, Racket, RDF TriG, RDF Turtle, Relax NG, reStructuredText, RPM spec, Ruby, SASS/SCSS, Scala, Slim, SML, Solidity, Sphinx, SQL, Stylus, Tcl, TeX, Texinfo, Twig, TypeScript, Vala, Verilog, VHDL, Vim help, VimL, Vue.js, xHtml, XML, XSLT, XQuery, YACC, YAML, YANG data models, YARA rules, z80, Zope page templates, and Zsh. See the manual for details about the corresponding supported checkers (:help syntastic-checkers in Vim).

ghcjs - Haskell to JavaScript compiler, based on GHC

  •    Haskell

Get GHC 7.10.2 (MinGHC on Windows) and make sure that happy is installed. On linux you may need to install a package like libtinfo-dev to make the Haskell terminfo package work. GHCJS is a Haskell to JavaScript compiler that uses the GHC API.

eff - 🚧 a work in progress effect system for Haskell 🚧

  •    Haskell

eff is really fast. Built on top of low-level primitives added to the GHC RTS to support capturing slices of the call stack, eff is performant by design. Using a direct implementation of delimited control allows it to be fast without relying on fickle compiler optimizations to eliminate indirection. Traditional effect system microbenchmarks fail to capture the performance of real code, as they are so small that GHC often ends up inlining everything. In real programs, GHC compiles most effect-polymorphic code via dictionary passing, not specialization, causing the performance of other effect systems to degrade beyond what microbenchmarks would imply. eff takes care to allow GHC to generate efficient code without the need for whole-program specialization.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.