Difference between revisions of "Applications and libraries/Program development"

From HaskellWiki
Jump to navigation Jump to search
(+Hpc)
(Add "Packaging and distribution" section, add cabal-flatpak)
 
(64 intermediate revisions by 31 users not shown)
Line 1: Line 1:
−
{{unknown copyright}}
  
 
{{LibrariesPage}}
  
{{LibrariesPage}}
   
  +
A list of tools and libraries that are helpful when developing Haskell code.
−
== Tools for program development ==
  
−  
−
A list of tools that are helpful when developing Haskell code.
  
 
See also the [[Libraries and tools/Compiler tools|compiler tools]] and [[Libraries and tools/Theorem provers|theorem provers]].
  
See also the [[Libraries and tools/Compiler tools|compiler tools]] and [[Libraries and tools/Theorem provers|theorem provers]].
   
−
=== Preprocesors ===
 +
== Applications ==
  +
  +
=== Preprocessors ===
   
 
;[http://www.cs.york.ac.uk/fp/cpphs/ cpphs]
  
;[http://www.cs.york.ac.uk/fp/cpphs/ cpphs]
 
:Cpphs is a re-implementation (in Haskell) of the C pre-processor.
  
:Cpphs is a re-implementation (in Haskell) of the C pre-processor.
   
−
;[http://repetae.net/john/computer/haskell/DrIFT DrIFT]
 +
;[http://repetae.net/computer/haskell/DrIFT/ DrIFT]
−
:DrIFT is a tool which allows derivation of instances for classes that aren't supported by the standard compilers. In addition, instances can be produced in seperate modules to that containing the type declaration. This allows instances to be derived for a type after the original module has been compiled. As a bonus, simple utility functions can also be produced from a type.
 +
:DrIFT is a tool which allows derivation of instances for classes that aren't supported by the standard compilers. In addition, instances can be produced in separate modules to that containing the type declaration. This allows instances to be derived for a type after the original module has been compiled. As a bonus, simple utility functions can also be produced from a type.
   
−
;[http://www.cs.vu.nl/Strafunski/ Strafunski]
 +
;[[Applications and libraries/Generic programming/Strafunski|Strafunski]]
 
:Strafunski is a Haskell bundle that provides support for generic programming in Haskell, based on the concept of a functional strategy. It consists of a combinator library (StrategyLib) and a precompiler (DrIFT-Strafunski).
  
:Strafunski is a Haskell bundle that provides support for generic programming in Haskell, based on the concept of a functional strategy. It consists of a combinator library (StrategyLib) and a precompiler (DrIFT-Strafunski).
   
−
;[http://darcs.haskell.org/~lemmih/zerothHead/ Zeroth]
 +
;[http://hackage.haskell.org/cgi-bin/hackage-scripts/package/zeroth Zeroth]
 
:A program using Template Haskell must link with the TH library even if it contains no references to TH after it has been compiled. Zeroth is a preprocessor which allows modules to use TH without linking with the TH library. To do this, Zeroth evaluates the top level splices from a module and saves the resulting code.
  
:A program using Template Haskell must link with the TH library even if it contains no references to TH after it has been compiled. Zeroth is a preprocessor which allows modules to use TH without linking with the TH library. To do this, Zeroth evaluates the top level splices from a module and saves the resulting code.
  +
  +
;[http://www.cs.utah.edu/~hal/HAllInOne/index.html Haskell All-In-One]
  +
:Haskell All-In-One is a Haskell utility which will take a program implemented in multiple modules and convert it to a single module, for optimisation purposes.
   
 
=== Build systems ===
  
=== Build systems ===
Line 29: Line 31:
 
:Automatically keeps track of module dependencies (i.e. no need to write any Makefiles!). Can be used with any of the usual Haskell compilers (ghc, hbc, nhc98).
  
:Automatically keeps track of module dependencies (i.e. no need to write any Makefiles!). Can be used with any of the usual Haskell compilers (ghc, hbc, nhc98).
   
−
=== Tags ===
 +
=== Source tags ===
   
−
;[http://www.cl.cam.ac.uk/users/rje33/software.html HaskTags]
 +
;[http://code.haskell.org/hasktags HaskTags]
 
:Hasktags is a simple program that generates TAGS files for Haskell code. Together with a supporting editor (e.g. NEdit, XEmacs, or Vim) TAGS files can be used to quickly find the places where functions, data constructors etc. are defined.
  
:Hasktags is a simple program that generates TAGS files for Haskell code. Together with a supporting editor (e.g. NEdit, XEmacs, or Vim) TAGS files can be used to quickly find the places where functions, data constructors etc. are defined.
  +
  +
;[http://hackage.haskell.org/package/hothasktags HotHaskTags]
  +
:HotHaskTags is a reimplementation of HaskTags that is more aware of the structure of Haskell source. If you have multiple functions of the same name in a project and jump from a file, it will analyze the imports of that file (including qualified imports correctly) and jump to the one that is being referred to. Extended ctags format only (read: Vim only).
  +
  +
;[http://kingfisher.nfshost.com/sw/gasbag/ gasbag]
  +
:Another reimplementation of hasktags which has a better understanding (than hasktags) of Haskell syntax. ctags files are generated in the traditional format only; where the same identifier is reused, gasbag attempts to determine the best one for inclusion in the ctags file.
   
 
;[http://www.dtek.chalmers.se/~d99josve/tagsh.tar.gz tagsh]
  
;[http://www.dtek.chalmers.se/~d99josve/tagsh.tar.gz tagsh]
Line 42: Line 50:
 
:Mechanical refactoring of Haskell code (across module boundaries). HaRe now supports many refactorings such as renaming identifiers, moving/introducing/inlining definitions, and so on. Those refactorings are not limited to a single module. HaRe can be accessed from either Vim or Emacs
  
:Mechanical refactoring of Haskell code (across module boundaries). HaRe now supports many refactorings such as renaming identifiers, moving/introducing/inlining definitions, and so on. Those refactorings are not limited to a single module. HaRe can be accessed from either Vim or Emacs
   
−
;[http://www.isi.edu/~hdaume/HAllInOne/ Haskell All-In-One]
 +
;[http://www.cs.utah.edu/~hal/HAllInOne/ Haskell All-In-One]
−
:This Haskell utility takes a program implemented in multiple modules and converts it to a single module.
 +
:This Haskell utility takes a program implemented in multiple modules and converts it to a single module. This way you get whole program optimization for compilers that do not support that. Resulting programs will be probably faster using this method.
   
 
;[http://wiki.di.uminho.pt/wiki/bin/view/Alcino/DrHylo DrHylo]
  
;[http://wiki.di.uminho.pt/wiki/bin/view/Alcino/DrHylo DrHylo]
 
:Tool for deriving hylomorphisms from a restricted Haskell syntax. It is based on the algorithm first presented in the paper "Deriving Structural Hylomorphisms From Recursive Definitions" at ICFP'96 by Hu, Iwasaki, and Takeichi.
  
:Tool for deriving hylomorphisms from a restricted Haskell syntax. It is based on the algorithm first presented in the paper "Deriving Structural Hylomorphisms From Recursive Definitions" at ICFP'96 by Hu, Iwasaki, and Takeichi.
   
  +
;[http://community.haskell.org/~ndm/hlint/ HLint]
−
=== Integrated Development Environments ===
  
  +
:Tool for automatically suggesting program improvements - library functions you may have missed, instances of map or foldr etc.
   
  +
=== Documentation and browsing ===
−
;[http://eclipsefp.sourceforge.net/ Haskell support for Eclipse]
  
−
:Eclipse is an open, extensible IDE platform for "everything and nothing in particular". It is implemented in Java and runs on several platforms. The Java IDE built on top of it has already become very popular among Java developers. The Haskell tools extend it to support editing (syntax coloring, code assist), compiling, and running Haskell programs from within the IDE. More features like source code navigation, module browsing etc. will be added in the future.
  
   
−
;[http://www.dtek.chalmers.se/~d99josve/hide/ hIDE]
 +
;[http://www.haskell.org/hoogle/ Hoogle]
  +
:Hoogle is a Haskell API search engine. It allows you to search for a function in the standard libraries by either name, or by approximate type signature.
−
:hIDE is a GUI-based Haskell IDE written using gtk+hs. It does not include an editor but instead interfaces with NEdit, vim or GNU emacs.
  
   
  +
;[[Haddock]] A Haskell Documentation Tool
−
;[http://haskell.org/hide hIDE-2]
  
  +
:A tool for automatically generating documentation from annotated Haskell source code. It is primarily intended for documenting libraries, but it should be useful for any kind of Haskell code. Haddock lets you write documentation annotations next to the definitions of functions and types in the source code, in a syntax that is easy on the eye when writing the source code (no heavyweight mark-up). The documentation generated by Haddock is fully hyperlinked - click on a type name in a type signature to go straight to the definition, and documentation, for that type.
−
:Through the dark ages many a programmer has longed for the ultimate tool. In response to this most unnerving craving, of which we ourselves have had maybe more than our fair share, the dynamic trio of #Haskellaniacs (dons, dcoutts and Lemmih) hereby announce, to the relief of the community, that a fetus has been conceived: ''hIDE - the Haskell Integrated Development Environment''. So far the unborn integrates source code recognition and a chameleon editor, resenting these in a snappy gtk2 environment. Although no seer has yet predicted the date of birth of our hIDEous creature, we hope that the mere knowledge of its existence will spread peace of mind throughout the community as oil on troubled waters. See also: [[Screenshots of HIDE]] and [[HIDE]]
  
   
−
;[http://www.students.cs.uu.nl/people/rjchaaft/JCreator JCreator with Haskell support]
 +
;[http://www.cse.unsw.edu.au/~chak/haskell/idoc/ IDoc] A No Frills Haskell Interface Documentation System
  +
:IDoc extracts interface documentation and declarations from Haskell modules based on standard Haskell layout rules and a small number of clues that the programmer embeds in interface comments. These clues have been designed to be visually non-imposing when displaying the source in a text editor. Interface documentation is rendered in standard markup languages (currently, only HTML is supported). IDoc has been designed to be simple to use and install.
−
:JCreator is a highly customizable Java IDE for Windows. Features include extensive project support, fully customizable toolbars (including the images of user tools) and menus, increase/decrease indent for a selected block of text (tab/shift+tab respectively). The Haskell support module adds syntax highlighting for haskell files and winhugs, hugs, a static checker (if you double click on the error message, JCreator will jump to the right file and line and highlight it yellow) and the Haskell 98 Report as tools. Platforms: Win95, Win98, WinNT and Win2000 (only Win95 not tested yet). Size: 6MB. JCreator is a trademark of Xinox Software; Copyright © 2000 Xinox Software The Haskell support module is made by [http://www.students.cs.uu.nl/people/rjchaaft/ Rijk-Jan van Haaften].
  
   
  +
;[http://staff.fmi.uni-passau.de/~groessli/hdoc/ HDoc]
−
;[http://www.haskell.org/visualhaskell Visual Haskell]
  
  +
:HDoc generates documentation in HTML format for Haskell modules. The generated documents are cross linked and include summaries and detailed descriptions for the documented functions, data types, type classes and instance declarations.
−
:Visual Haskell is a complete development environment for Haskell software, based on Microsoft's [http://msdn.microsoft.com/vstudio/productinfo/ Microsoft Visual Studio] platform. Visual Haskell integrates with the Visual Studio editor to provide interactive features to aid Haskell development, and it enables the construction of projects consisting of multiple Haskell modules, using the Cabal building/packaging infrastructure.
  
   
−
;[http://www.kdevelop.org/ KDevelop]
 +
;[http://www.ida.liu.se/~jakax/haskell.html HaskellDoc]
  +
:This program generates an HTML document showing the module interfaces of a Haskell project. Convenient links are placed for easy browsing of the different modules of the project, and for quick access to the source code.
−
:This IDE supports many languages. For Haskell it [http://www.kdevelop.org/HEAD/doc/api/html/LangSupportStatus.html currently supports] project management, syntax highlighting, building (with GHC) & executing within the IDE.
  
   
  +
;[http://home.conceptsfa.nl/~jwit/HaSpell.html HaSpell]
−
;[http://haste.dyndns.org:8080/ haste - Haskell TurboEdit]
  
  +
:HaSpell is a spelling and style checker for Haskell programs. It can detect spelling errors in comments in the program text, and optionally in the code itself. There is an option to detect metasyntactic variables (such as 'foo') and 'bad function prefixes' such as 'compute' and 'doThe' - these make the program less readable and generally indicate bad programming style.
−
:haste - Haskell TurboEdit - is an IDE for the functional programming language Haskell, written in Haskell.
  
   
  +
;[[Lambdabot]]
−
;[http://www.cs.kent.ac.uk/projects/vital/ Vital]
  
  +
:Lambdabot is a large, ad-hoc collection of Haskell development tools available for offline use. In particular, automatic point-free refactoring is available via a vim interface, as well as access to [[Hoogle]], djinn, ghci, and much much more.
−
:Vital is a visual programming environment. It is particularly intended for supporting the open-ended, incremental style of development often preferred by end users (engineers, scientists, analysts, etc.).
  
   
  +
=== Tracing & debugging ===
−
;[http://www.cs.kent.ac.uk/projects/pivotal/ Pivotal]
  
−
:Pivotal 0.025 is an early prototype of a Vital-like environment for Haskell. Unlike Vital, however, Pivotal is implemented entirely in Haskell. The implementation is based on the use of the hs-plugins library to allow dynamic compilation and evaluation of Haskell expressions together with the gtk2hs library for implementing the GUI.
  
   
  +
Tracing gives access to otherwise invisible information about a computation. Conventional debuggers allow the user to step through the program computation, stop at given points and examine variable contents. This tracing method is quite unsuitable for Haskell, because its evaluation order is complex, function arguments are usually unwieldy large unevaluated expressions and generally
−
=== Editor modes for syntax highlighting ===
  
  +
computation details do not match the user's high-level view of functions mapping values to values.
   
  +
;[http://www.cs.mu.oz.au/~bjpop/buddha/ Buddha]
−
====Kate====
  
  +
:Buddha is a declarative debugger for Haskell 98 programs. It presents the evaluation of a Haskell program as a series of function applications. A typical debugging session involves a series of questions and answers. The questions are posed by the debugger, and the answers are provided by the user. The implementation of Buddha is based on program transformation.
  +
  +
;[http://www.ida.liu.se/~henni Freja]
  +
:A compiler for a subset of Haskell. Running a compiled program creates an evaluation dependency tree as trace, a structure based on the idea of declarative debugging from the logic programming community. A debugging session consists of the user answering a sequence of yes/no questions.
   
  +
;[http://www.cs.york.ac.uk/fp/hat Hat]
−
; Syntax highlighting files for KDE's Kate
  
  +
:A Haskell program is first transformed by hat-trans and then compiled with nhc98 or ghc. At runtime the program writes a trace file. There are tools for viewing the trace in various ways: Hat-stack shows a virtual stack of redexes. Hat-observe shows top-level functions in the style of Hood. Hat-trail enables exploring a computation backwards, starting from (part of) a faulty output or an error message. Hat-detect provides algorithmic debugging in the style of Freja. Hat-explore allows free navigation through a computation similar to traditional debuggers and algorithmic debugging and slicing.
−
:
  
−
* [http://www.informatik.uni-bonn.de/~ralf/software.html#syntax Files] by Ralf Hinze.
  
−
* [hs.xml hs.xml] and [lhs.xml lhs.xml] by Brian Huffman.
  
   
  +
;[http://www.ittc.ku.edu/csdl/fpg/Tools/Hood Hood]
−
====NEdit====
  
  +
:A library that permits to observe data structures at given program points. It can basically be used like print statements in imperative languages, but the lazy evaluation order is not affected and functions can be observed as well.
   
  +
;[http://community.haskell.org/~claus/GHood/ GHood]
−
;[http://www.nedit.org/ftp/contrib/highlighting/haskell.pats NEdit] syntax highlighting and block comment support.
  
  +
:"Graphical Hood" - a Java-based graphical observation event viewer, building on Hood.
   
−
====Vim====
 +
=== Revision control ===
   
−
;[http://www.vim.org vim] syntax highlighting
 +
;[http://darcs.net Darcs]
  +
: Darcs is a cutting edge revision control system written in Haskell
−
:
  
−
* [ftp://ftp.cse.unsw.edu.au/pub/users/dons/vim/ by Don Stewart]: for TeX and cpp style Haskell files.
 
−
* [http://urchin.earth.li/~ian/vim/ by Ian Lynagh]: distinguishes different literal Haskell styles.
  
−
* by John Williams: Both regular Haskell [haskell.vim .hs] and [lhaskell.vim .lhs] files that uncomment lines using '>' are supported.
  
   
  +
;[http://code.haskell.org/~dons/code/darcs-graph/ darcs-graph]
−
====Textpad====
  
  +
:a tool for generating graphs of commit activity for darcs repositories.
   
  +
;[http://www.cse.unsw.edu.au/~chak/haskell/VersionTool/ VersionTool]
−
;[http://www.haskell.org/libraries/Haskell98.syn Syntax highlighting file] for [http://www.textpad.com textpad]
  
  +
:a small utility that:
−
:by Jeroen van Wolffelaar and Arjan van IJzerdoorn, which inludes all prelude functions, datatype, constructors, etc, all in seperate groups.
  
  +
* extracts version information from Cabal files,
  +
* maintains version tags in darcs,
  +
* computes patch levels by querying darcs,
  +
* extracts the current context from darcs, and
  +
* adds all this information to a source file
   
  +
;[http://hackage.haskell.org/package/hit Hit]
−
====Emacs====
  
  +
: Git storage re-implementation in Haskell, allowing to read and write objects from a Haskell program easily.
   
  +
=== Licensing ===
−
;[http://www.haskell.org/haskell-mode/ Haskell Mode for Emacs]
  
−
:Supports font locking, declaration scanning, documentation of types, indentation and interaction with Hugs.
  
   
−
;Alternative [http://www.haskell.org/libraries/hugs-mode.el Hugs Mode for Emacs] by Chris Van Humbeeck
 +
;[http://www.haskell.org/pipermail/haskell/2006-June/018043.html Kamiariduki]
  +
:a system to judge your derivative work's purpose and license is valid with Creative Commons License Works.
−
:Provides fontification and cooperation with Hugs. Updated for emacs 20.* by Adam P. Jenkins.
  
   
−
====Jed====
 +
=== Bug tracking ===
   
  +
;[http://urchin.earth.li/darcs/ian/bts/ Bark]
−
;[http://www.astercity.net/~khaliff/haskell/haskellmode.tgz Haskell mode] {{dead link}}
  
  +
:Bark is a bug tracking system written in Haskell
−
:for [http://www.jedsoft.org/jed/ jed] by Marcin 'Qrczak' Kowalczyk.
  
   
−
====Subethaedit====
 +
=== Typesetting Haskell ===
   
  +
;[http://www.cs.york.ac.uk/fp/darcs/hscolour/ HsColour]
−
;[http://www.codingmonkeys.de/subethaedit/modes.html Haskell mode For SubEthaEdit]
  
  +
:Colourise Haskell source code in HTML or ANSI terminal screen codes.
−
: SubEthaEdit is a Mac OS X editor.
  
   
  +
;[https://www.andres-loeh.de/lhs2tex lhs2tex]
−
====Other====
  
  +
:A preprocessor for typesetting Haskell programs that combines some of the good features of pphs and smugweb. It generates LaTeX code from literate Haskell sources.
   
  +
;[http://www.cs.uu.nl/wiki/Ehc/Shuffle Shuffle]
−
Some other, mostly obsolete, modes are available in [http://cvs.haskell.org/cgi-bin/cvsweb.cgi/fptools/CONTRIB/haskell-modes/ CVS].
  
  +
:Another tool helping literate programming in Haskell. It helps to maintain ''views'' in a literate programming project. For example, it is among the tools used for developing a compiler in an iterative way with manuals didactically reflecting these evolving series of versions deriving from the literal code (see [http://www.cs.uu.nl/wiki/Ehc/WebHome Essential Haskell Compiler] project). Thus, Shuffle gives us the possibility for making didactically the evolution of versions visible in the documentation, when this is needed. More generally, Shuffle gives us tangling and weaving possibilities of literate programming. I think it gives a way to think of literal program development in a more abstract way by supporting the concept of views (maybe a too far analogy: version control management -- e.g. [http://abridgegame.org/darcs/ darcs] -- helps thinking of program development in a more abstract way, too). Shuffle works well together with lhs2tex.
   
  +
;[http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/Haskell2LaTeX/ Haskell2Latex]
−
=== Typesetting Haskell ===
  
  +
:Ian Lynagh's Haskell2LaTeX takes a literate Haskell program, or any LaTeX document with embedded Haskell, and pretty-prints the Haskell sections within it. The most significant difference between Haskell2LaTeX and other programs with similar goals is is that Haskell2LaTeX parses the input rather than merely lexing it.
   
  +
==== TeX ====
−
;[http://www.jantar.org/lambdaTeX/ lambdaTeX]
  
  +
  +
;[http://www.acooke.org/pancito-code/haskell.sty haskell.sty]
  +
:A Latex style file by Andrew Cooke that makes literal programming in Haskell simple.
  +
  +
;[http://www.jantar.org/lambdatex lambdaTeX]
 
:A TeX package for typesetting literate scripts in TeX. The output looks much like the code from Chris Okasaki's book "Purely Functional Data Structures", doing syntax highlighting and converting ASCII art such as <code>-&gt;</code> or <code>alpha</code> to proper mathematical symbols. It should work with both LaTeX and plain TeX, and it does its magic without any annotations, directly on the source code (lambdaTeX uses an almost-complete Haskell lexical analyzer written entirely in plain TeX). You only have to add <code>\input lambdaTeX</code> at the top of your source file, and manually typeset your literate comments so they look as good as the source code.
  
:A TeX package for typesetting literate scripts in TeX. The output looks much like the code from Chris Okasaki's book "Purely Functional Data Structures", doing syntax highlighting and converting ASCII art such as <code>-&gt;</code> or <code>alpha</code> to proper mathematical symbols. It should work with both LaTeX and plain TeX, and it does its magic without any annotations, directly on the source code (lambdaTeX uses an almost-complete Haskell lexical analyzer written entirely in plain TeX). You only have to add <code>\input lambdaTeX</code> at the top of your source file, and manually typeset your literate comments so they look as good as the source code.
   
Line 133: Line 156:
 
:by Manuel Chakravarty provides environments and macros that simplify setting Haskell programs in LaTeX.
  
:by Manuel Chakravarty provides environments and macros that simplify setting Haskell programs in LaTeX.
   
  +
=== Packaging and distribution ===
−
;[http://www.iai.uni-bonn.de/~loeh/lhs2tex/ lhs2tex]
  
−
:A preprocessor for typesetting Haskell programs that combines some of the good features of pphs and smugweb. It generates LaTeX code from literate Haskell sources.
  
   
  +
;[https://hackage.haskell.org/package/cabal-flatpak cabal-flatpak]
−
;[http://www.cs.uu.nl/wiki/Ehc/Shuffle Shuffle]
  
  +
:Generate a FlatPak manifest from a Cabal package description.
−
:another tool helping literate programming in Haskell. It helps to maintain ''views'' in a literate programming project. For example, it is among the tools used for developing a compiler in an iterative way with manuals didactically reflecting these evolving series of versions deriving from the literal code (see [http://www.cs.uu.nl/wiki/Ehc/WebHome Essential Haskell Compiler] project). Thus, Shuffle gives us the possibility for making didactically the evolution of versions visible in the documentation, when this is needed. More generally, Shuffle gives us tangling and weaving possibilities of literate programming. I think it gives a way to think of literal program development in a more abstract way by supporting the concept of views (maybe a too far analogy: version control management -- e.g. [http://abridgegame.org/darcs/ darcs] -- helps thinking of program development in a more abstract way, too). Shuffle works well together with lhs2tex.
  
   
  +
== Editor support ==
−
;[http://www.acooke.org/jara/pancito/haskell.sty haskell.sty]
  
−
:A Latex style file by Andrew Cooke that makes literal programming in Haskell simple.
  
   
  +
=== Integrated Development Environments ===
−
;[http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/Haskell2LaTeX/ Haskell2Latex]
  
−
:Ian Lynagh's Haskell2LaTeX takes a literate Haskell program, or any LaTeX document with embedded Haskell, and pretty-prints the Haskell sections within it. The most significant difference between Haskell2LaTeX and other programs with similar goals is is that Haskell2LaTeX parses the input rather than merely lexing it.
  
   
  +
See [[IDEs]].
−
;[ftp://ftp.cs.york.ac.uk/pub/haskell/contrib/hscolour-1.1.tar.gz HsColour]
  
−
:Colourise Haskell source code in HTML or ANSI terminal screen codes.
  
   
−
=== Source documentation and browsing ===
 +
=== Editor modes ===
   
  +
''See [[IDEs#Vim]] and [[IDEs#Emacs]] for integration support of those editors.
−
;[[Haddock]] A Haskell Documentation Tool
  
−
:A tool for automatically generating documentation from annotated Haskell source code. It is primarily intended for documenting libraries, but it should be useful for any kind of Haskell code. Haddock lets you write documentation annotations next to the definitions of functions and types in the source code, in a syntax that is easy on the eye when writing the source code (no heavyweight mark-up). The documentation generated by Haddock is fully hyperlinked - click on a type name in a type signature to go straight to the definition, and documentation, for that type.
  
   
  +
;[http://www.crimsoneditor.com/ Crimson Editor]
−
;[http://www.cse.unsw.edu.au/~chak/haskell/idoc/ IDoc] A No Frills Haskell Interface Documentation System
  
  +
:Free source code editor for MS Windows. Haskell support files are included in the standard installation, but must be added to the editor via the options dialog.
−
:IDoc extracts interface documentation and declarations from Haskell modules based on standard Haskell layout rules and a small number of clues that the programmer embeds in interface comments. These clues have been designed to be visually non-imposing when displaying the source in a text editor. Interface documentation is rendered in standard markup languages (currently, only HTML is supported). IDoc has been designed to be simple to use and install.
  
   
−
;[http://www.fmi.uni-passau.de/~groessli/hdoc/ HDoc]
 +
;[http://kate-editor.org/ Kate]
  +
:Syntax highlighting files for KDE's Kate
−
:HDoc generates documentation in HTML format for Haskell modules. The generated documents are cross linked and include summaries and detailed descriptions for the documented functions, data types, type classes and instance declarations.
  
  +
:* [https://github.com/zenzike/kate-haskel Files] by Nicolas Wu
  +
:* [http://www.informatik.uni-bonn.de/~ralf/software.html#syntax Files] by Ralf Hinze.
  +
:* [hs.xml hs.xml] and [lhs.xml lhs.xml] by Brian Huffman.
   
−
;[http://www.ida.liu.se/~jakax/haskell.html HaskellDoc]
 +
;[http://www.nedit.org NEdit]
  +
:[http://www.nedit.org/ftp/contrib/highlighting/haskell.pats Syntax highlighting] and block comment support.
−
:This program generates an HTML document showing the module interfaces of a Haskell project. Convenient links are placed for easy browsing of the different modules of the project, and for quick access to the source code.
  
  +
  +
;[http://www.textpad.com TextPad]
  +
:[http://www.haskell.org/libraries/Haskell98.syn Syntax highlighting file] by Jeroen van Wolffelaar and Arjan van IJzerdoorn, which inludes all prelude functions, datatype, constructors, etc, all in separate groups.
   
−
;[http://home.conceptsfa.nl/~jwit/HaSpell.html HaSpell]
 +
;[http://www.jedsoft.org/jed/ Jed]
  +
:[http://haskell.org/sitewiki/images/7/75/Haskellmode-jed.tgz Haskell mode] by Marcin 'Qrczak' Kowalczyk.
−
:HaSpell is a spelling and style checker for Haskell programs. It can detect spelling errors in comments in the program text, and optionally in the code itself. There is an option to detect metasyntactic variables (such as 'foo') and 'bad function prefixes' such as 'compute' and 'doThe' - these make the program less readable and generally indicate bad programming style.
  
  +
  +
;[http://www.codingmonkeys.de/subethaedit/ SubEthaEdit]
  +
:[http://www.codingmonkeys.de/subethaedit/modes.html Haskell mode For SubEthaEdit]
  +
  +
;[http://developer.apple.com/technologies/tools/ Xcode]
  +
:[http://www.hoovy.org/HaskellXcodePlugin/ Xcode plugin] for enabling syntax highlighting, Xcode projects compiling and linking, and a couple missing features, for Haskell
  +
  +
====Other====
  +
  +
Some other, mostly obsolete, modes are available in [http://cvs.haskell.org/cgi-bin/cvsweb.cgi/fptools/CONTRIB/haskell-modes/ CVS].
  +
  +
== Libraries ==
   
 
=== Testing ===
  
=== Testing ===
Line 176: Line 212:
 
:The HTF lets you write HUnit tests and QuickCheck properties in an easy and convenient way. Additionally, the HTF provides a facility for testing programs by running them and comparing the actual output with the expected output (so called "file-based tests"). The HTF uses Template Haskell to collect all tests and properties, so you do not need to write boilerplate code for that purpose. Preprocessor macros provide you with file name and line number information for tests and properties that failed.
  
:The HTF lets you write HUnit tests and QuickCheck properties in an easy and convenient way. Additionally, the HTF provides a facility for testing programs by running them and comparing the actual output with the expected output (so called "file-based tests"). The HTF uses Template Haskell to collect all tests and properties, so you do not need to write boilerplate code for that purpose. Preprocessor macros provide you with file name and line number information for tests and properties that failed.
   
  +
;[https://github.com/hspec/hspec HSpec]
−
;[http://www.galois.com/~andy/hpc-intro.html Hpc: Haskell Program Coverage]
  
  +
:Hspec is a testing framework for Haskell. It is roughly based on the Ruby library RSpec. Some of Hspec's distinctive features are: a friendly DSL for defining tests, integration with QuickCheck, SmallCheck, and HUnit, parallel test execution, and automatic discovery of test files.
−
:Hpc is a tool-kit to record and display Haskell program coverage. Hpc includes tools that instrument Haskell programs to record program coverage, run instrumented programs, and display the coverage information obtained.
  
   
  +
;[http://projects.unsafeperformio.com/hpc/ Hpc: Haskell Program Coverage]
−
=== Tracing &amp; debugging ===
  
  +
:Hpc is a tool-kit to record and display [[Haskell program coverage]]. Hpc includes tools that instrument Haskell programs to record program coverage, run instrumented programs, and display the coverage information obtained.
   
  +
;[[Haskell Equational Reasoning Assistant]]
−
Tracing gives access to otherwise invisible information about a computation. Conventional debuggers allow the user to step through the program computation, stop at given points and examine variable contents. This tracing method is quite unsuitable for Haskell, because its evaluation order is complex, function arguments are usually unwieldy large unevaluated expressions and generally
  
  +
:Functional programmers often appeal to equational reasoning to justify various decisions made in both design and implementation. This page introduces the Haskell Equational Reasoning Assistant (HERA), an architecture that provides both a GUI level and a batch level Haskell rewrite engine inside a single tool.
−
computation details do not match the user's high-level view of functions mapping values to values.
 
   
−
;[http://www.cs.mu.oz.au/~bjpop/buddha/ Buddha]
 +
;[http://www.cse.unsw.edu.au/~dons/pqc.html pQC: parallel QuickCheck]
  +
:pqc provides Test.QuickCheck.Parallel, a QuickCheck driver that runs jobs in parallel, and will utilise as many cores as you wish, with the SMP parallel GHC 6.6 runtime. It is simple, scalable replacement for Test.QuickCheck.Batch.
−
:Buddha is a declarative debugger for Haskell 98 programs. It presents the evaluation of a Haskell program as a series of function applications. A typical debugging session involves a series of questions and answers. The questions are posed by the debugger, and the answers are provided by the user. The implementation of Buddha is based on program transformation.
  
−
 
−
;[http://www.ida.liu.se/~henni Freja]
  
−
:A compiler for a subset of Haskell. Running a compiled program creates an evaluation dependency tree as trace, a structure based on the idea of declarative debugging from the logic programming community. A debugging session consists of the user answering a sequence of yes/no questions.
  
   
  +
=== Debugging ===
−
;[http://www.cs.york.ac.uk/fp/hat Hat]
  
−
:A Haskell program is first transformed by hat-trans and then compiled with nhc98 or ghc. At runtime the program writes a trace file. There are tools for viewing the trace in various ways: Hat-stack shows a virtual stack of redexes. Hat-observe shows top-level functions in the style of Hood. Hat-trail enables exploring a computation backwards, starting from (part of) a faulty output or an error message. Hat-detect provides algorithmic debugging in the style of Freja. Hat-explore allows free navigation through a computation similar to traditional debuggers and algorithmic debugging and slicing.
  
−  
−
;[http://www.haskell.org/hood Hood]
  
−
:A library that permits to observe data structures at given program points. It can basically be used like print statements in imperative languages, but the lazy evaluation order is not affected and functions can be observed as well.
  
−  
−
;[http://www.cs.ukc.ac.uk/people/staff/cr3/toolbox/haskell/ GHood]
  
−
:"Graphical Hood" - a Java-based graphical observation event viewer, building on Hood.
  
   
 
;[http://www.cs.mu.oz.au/~bjpop/code.html highWaterMark]
  
;[http://www.cs.mu.oz.au/~bjpop/code.html highWaterMark]
Line 208: Line 235:
 
:Two libraries for GHC. The first is for printing heap objects from within Haskell or C code. The second is for dumping the contents of the Stable Table which is used for Stable Pointers and Stable Names.
  
:Two libraries for GHC. The first is for printing heap objects from within Haskell or C code. The second is for dumping the contents of the Stable Table which is used for Stable Pointers and Stable Names.
   
  +
;[http://www.cse.unsw.edu.au/~dons/loch.html LocH]
−
=== Bug tracking ===
  
  +
:Located errors, tracing and exceptions in Haskell.
−  
−
;[http://urchin.earth.li/darcs/ian/bts/ Bark]
 
−
:Bark is a bug tracking system written in Haskell
  
−  
−
=== Miscellaneous ===
  
−  
−
;[http://www.haskell.org/hoogle/ Hoogle]
  
−
:Hoogle is a Haskell API search engine. It allows you to search for a function in the standard libraries by either name, or by approximate type signature.
  
−  
−
;[[Lambdabot]]
  
−
:Once an IRC bot, this has grown to be a large, ad-hoc collection of Haskell development tools available for offline use. In particular, automatic point-free refactoring is available via a vim interface, as well as access to [[Hoogle]], djinn, ghci, and much much more.
  
−  
−
;[http://www.cse.unsw.edu.au/~dons/darcs-graph.html darcs-graph]
  
−
:a tool for generating graphs of commit activity for darcs repositories.
  
−  
−
;[http://www.cse.unsw.edu.au/~chak/haskell/VersionTool/ VersionTool]
  
−
:a small utility that:
  
−
* extracts version information from Cabal files,
  
−
* maintains version tags in darcs,
  
−
* computes patch levels by querying darcs,
  
−
* extracts the current context from darcs, and
  
−
* adds all this information to a source file
  
−  
−
;[http://www.haskell.org/pipermail/haskell/2006-June/018043.html Kamiariduki]
  
−
:a system to judge your derivative work's purpose and license is valid with Creative Commons License Works.
  
   
 
=== Formal methods ===
  
=== Formal methods ===
   
  +
;[http://aprove.informatik.rwth-aachen.de Haskell98 termination analyzer]
−
See
  
  +
:Checks termination of given start terms w.r.t. a Haskell program:
 
* [[Analysis and design|analysis and design methods]]
  
* [[Analysis and design|analysis and design methods]]
 
* [[Libraries and tools/Theorem provers|theorem provers]].
  
* [[Libraries and tools/Theorem provers|theorem provers]].
−  
−
=== Dead ===
  
−  
−
;[http://web.archive.org/web/*/http://www.numeric-quest.com/haskell/explorer/browser.html The Haskell Module Browser]<em>(since 10/06/2003 via Internet Archive)</em>
  
−
:A browser similar to Smaltalk and Eiffel class browsers.
  

Latest revision as of 13:50, 22 August 2022

This page contains a list of libraries and tools in a certain category. For a comprehensive list of such pages, see Applications and libraries.

A list of tools and libraries that are helpful when developing Haskell code. See also the compiler tools and theorem provers.

Applications

Preprocessors

cpphs
Cpphs is a re-implementation (in Haskell) of the C pre-processor.
DrIFT
DrIFT is a tool which allows derivation of instances for classes that aren't supported by the standard compilers. In addition, instances can be produced in separate modules to that containing the type declaration. This allows instances to be derived for a type after the original module has been compiled. As a bonus, simple utility functions can also be produced from a type.
Strafunski
Strafunski is a Haskell bundle that provides support for generic programming in Haskell, based on the concept of a functional strategy. It consists of a combinator library (StrategyLib) and a precompiler (DrIFT-Strafunski).
Zeroth
A program using Template Haskell must link with the TH library even if it contains no references to TH after it has been compiled. Zeroth is a preprocessor which allows modules to use TH without linking with the TH library. To do this, Zeroth evaluates the top level splices from a module and saves the resulting code.
Haskell All-In-One
Haskell All-In-One is a Haskell utility which will take a program implemented in multiple modules and convert it to a single module, for optimisation purposes.

Build systems

Cabal
The Haskell Cabal is a Common Architecture for Building Applications and Libraries. It is an API distributed with GHC, NHC98, and Hugs which allows a developer to easily group together a set of modules into a package. It is the standard build system for new Haskell libraries and applications
hmake, a Haskell-aware replacement for make
Automatically keeps track of module dependencies (i.e. no need to write any Makefiles!). Can be used with any of the usual Haskell compilers (ghc, hbc, nhc98).

Source tags

HaskTags
Hasktags is a simple program that generates TAGS files for Haskell code. Together with a supporting editor (e.g. NEdit, XEmacs, or Vim) TAGS files can be used to quickly find the places where functions, data constructors etc. are defined.
HotHaskTags
HotHaskTags is a reimplementation of HaskTags that is more aware of the structure of Haskell source. If you have multiple functions of the same name in a project and jump from a file, it will analyze the imports of that file (including qualified imports correctly) and jump to the one that is being referred to. Extended ctags format only (read: Vim only).
gasbag
Another reimplementation of hasktags which has a better understanding (than hasktags) of Haskell syntax. ctags files are generated in the traditional format only; where the same identifier is reused, gasbag attempts to determine the best one for inclusion in the ctags file.
tagsh
A version of the tags program for Haskell. It uses the standardised hssource and posix library, works with GHC 5.02.1. tags file has been checked to work with vim and nedit.

Program Transformation

HaRe -- The Haskell Refactorer
Mechanical refactoring of Haskell code (across module boundaries). HaRe now supports many refactorings such as renaming identifiers, moving/introducing/inlining definitions, and so on. Those refactorings are not limited to a single module. HaRe can be accessed from either Vim or Emacs
Haskell All-In-One
This Haskell utility takes a program implemented in multiple modules and converts it to a single module. This way you get whole program optimization for compilers that do not support that. Resulting programs will be probably faster using this method.
DrHylo
Tool for deriving hylomorphisms from a restricted Haskell syntax. It is based on the algorithm first presented in the paper "Deriving Structural Hylomorphisms From Recursive Definitions" at ICFP'96 by Hu, Iwasaki, and Takeichi.
HLint
Tool for automatically suggesting program improvements - library functions you may have missed, instances of map or foldr etc.

Documentation and browsing

Hoogle
Hoogle is a Haskell API search engine. It allows you to search for a function in the standard libraries by either name, or by approximate type signature.
Haddock A Haskell Documentation Tool
A tool for automatically generating documentation from annotated Haskell source code. It is primarily intended for documenting libraries, but it should be useful for any kind of Haskell code. Haddock lets you write documentation annotations next to the definitions of functions and types in the source code, in a syntax that is easy on the eye when writing the source code (no heavyweight mark-up). The documentation generated by Haddock is fully hyperlinked - click on a type name in a type signature to go straight to the definition, and documentation, for that type.
IDoc A No Frills Haskell Interface Documentation System
IDoc extracts interface documentation and declarations from Haskell modules based on standard Haskell layout rules and a small number of clues that the programmer embeds in interface comments. These clues have been designed to be visually non-imposing when displaying the source in a text editor. Interface documentation is rendered in standard markup languages (currently, only HTML is supported). IDoc has been designed to be simple to use and install.
HDoc
HDoc generates documentation in HTML format for Haskell modules. The generated documents are cross linked and include summaries and detailed descriptions for the documented functions, data types, type classes and instance declarations.
HaskellDoc
This program generates an HTML document showing the module interfaces of a Haskell project. Convenient links are placed for easy browsing of the different modules of the project, and for quick access to the source code.
HaSpell
HaSpell is a spelling and style checker for Haskell programs. It can detect spelling errors in comments in the program text, and optionally in the code itself. There is an option to detect metasyntactic variables (such as 'foo') and 'bad function prefixes' such as 'compute' and 'doThe' - these make the program less readable and generally indicate bad programming style.
Lambdabot
Lambdabot is a large, ad-hoc collection of Haskell development tools available for offline use. In particular, automatic point-free refactoring is available via a vim interface, as well as access to Hoogle, djinn, ghci, and much much more.

Tracing & debugging

Tracing gives access to otherwise invisible information about a computation. Conventional debuggers allow the user to step through the program computation, stop at given points and examine variable contents. This tracing method is quite unsuitable for Haskell, because its evaluation order is complex, function arguments are usually unwieldy large unevaluated expressions and generally computation details do not match the user's high-level view of functions mapping values to values.

Buddha
Buddha is a declarative debugger for Haskell 98 programs. It presents the evaluation of a Haskell program as a series of function applications. A typical debugging session involves a series of questions and answers. The questions are posed by the debugger, and the answers are provided by the user. The implementation of Buddha is based on program transformation.
Freja
A compiler for a subset of Haskell. Running a compiled program creates an evaluation dependency tree as trace, a structure based on the idea of declarative debugging from the logic programming community. A debugging session consists of the user answering a sequence of yes/no questions.
Hat
A Haskell program is first transformed by hat-trans and then compiled with nhc98 or ghc. At runtime the program writes a trace file. There are tools for viewing the trace in various ways: Hat-stack shows a virtual stack of redexes. Hat-observe shows top-level functions in the style of Hood. Hat-trail enables exploring a computation backwards, starting from (part of) a faulty output or an error message. Hat-detect provides algorithmic debugging in the style of Freja. Hat-explore allows free navigation through a computation similar to traditional debuggers and algorithmic debugging and slicing.
Hood
A library that permits to observe data structures at given program points. It can basically be used like print statements in imperative languages, but the lazy evaluation order is not affected and functions can be observed as well.
GHood
"Graphical Hood" - a Java-based graphical observation event viewer, building on Hood.

Revision control

Darcs
Darcs is a cutting edge revision control system written in Haskell
darcs-graph
a tool for generating graphs of commit activity for darcs repositories.
VersionTool
a small utility that:
  • extracts version information from Cabal files,
  • maintains version tags in darcs,
  • computes patch levels by querying darcs,
  • extracts the current context from darcs, and
  • adds all this information to a source file
Hit
Git storage re-implementation in Haskell, allowing to read and write objects from a Haskell program easily.

Licensing

Kamiariduki
a system to judge your derivative work's purpose and license is valid with Creative Commons License Works.

Bug tracking

Bark
Bark is a bug tracking system written in Haskell

Typesetting Haskell

HsColour
Colourise Haskell source code in HTML or ANSI terminal screen codes.
lhs2tex
A preprocessor for typesetting Haskell programs that combines some of the good features of pphs and smugweb. It generates LaTeX code from literate Haskell sources.
Shuffle
Another tool helping literate programming in Haskell. It helps to maintain views in a literate programming project. For example, it is among the tools used for developing a compiler in an iterative way with manuals didactically reflecting these evolving series of versions deriving from the literal code (see Essential Haskell Compiler project). Thus, Shuffle gives us the possibility for making didactically the evolution of versions visible in the documentation, when this is needed. More generally, Shuffle gives us tangling and weaving possibilities of literate programming. I think it gives a way to think of literal program development in a more abstract way by supporting the concept of views (maybe a too far analogy: version control management -- e.g. darcs -- helps thinking of program development in a more abstract way, too). Shuffle works well together with lhs2tex.
Haskell2Latex
Ian Lynagh's Haskell2LaTeX takes a literate Haskell program, or any LaTeX document with embedded Haskell, and pretty-prints the Haskell sections within it. The most significant difference between Haskell2LaTeX and other programs with similar goals is is that Haskell2LaTeX parses the input rather than merely lexing it.

TeX

haskell.sty
A Latex style file by Andrew Cooke that makes literal programming in Haskell simple.
lambdaTeX
A TeX package for typesetting literate scripts in TeX. The output looks much like the code from Chris Okasaki's book "Purely Functional Data Structures", doing syntax highlighting and converting ASCII art such as -> or alpha to proper mathematical symbols. It should work with both LaTeX and plain TeX, and it does its magic without any annotations, directly on the source code (lambdaTeX uses an almost-complete Haskell lexical analyzer written entirely in plain TeX). You only have to add \input lambdaTeX at the top of your source file, and manually typeset your literate comments so they look as good as the source code.
Haskell Style for LaTeX2e
by Manuel Chakravarty provides environments and macros that simplify setting Haskell programs in LaTeX.

Packaging and distribution

cabal-flatpak
Generate a FlatPak manifest from a Cabal package description.

Editor support

Integrated Development Environments

See IDEs.

Editor modes

See IDEs#Vim and IDEs#Emacs for integration support of those editors.

Crimson Editor
Free source code editor for MS Windows. Haskell support files are included in the standard installation, but must be added to the editor via the options dialog.
Kate
Syntax highlighting files for KDE's Kate
  • Files by Nicolas Wu
  • Files by Ralf Hinze.
  • [hs.xml hs.xml] and [lhs.xml lhs.xml] by Brian Huffman.
NEdit
Syntax highlighting and block comment support.
TextPad
Syntax highlighting file by Jeroen van Wolffelaar and Arjan van IJzerdoorn, which inludes all prelude functions, datatype, constructors, etc, all in separate groups.
Jed
Haskell mode by Marcin 'Qrczak' Kowalczyk.
SubEthaEdit
Haskell mode For SubEthaEdit
Xcode
Xcode plugin for enabling syntax highlighting, Xcode projects compiling and linking, and a couple missing features, for Haskell

Other

Some other, mostly obsolete, modes are available in CVS.

Libraries

Testing

HUnit
A unit testing framework for Haskell, similar to JUnit for Java. With HUnit, the programmer can easily create tests, name them, group them into suites, and execute them, with the framework checking the results automatically. Test specification is concise, flexible, and convenient.
QuickCheck
A tool for testing Haskell programs automatically. The programmer provides a specification of the program, in the form of properties which functions should satisfy, and QuickCheck then tests that the properties hold in a large number of randomly generated cases. Specifications are expressed in Haskell, using combinators defined in the QuickCheck library. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators.
HTF - The Haskell Test Framework
The HTF lets you write HUnit tests and QuickCheck properties in an easy and convenient way. Additionally, the HTF provides a facility for testing programs by running them and comparing the actual output with the expected output (so called "file-based tests"). The HTF uses Template Haskell to collect all tests and properties, so you do not need to write boilerplate code for that purpose. Preprocessor macros provide you with file name and line number information for tests and properties that failed.
HSpec
Hspec is a testing framework for Haskell. It is roughly based on the Ruby library RSpec. Some of Hspec's distinctive features are: a friendly DSL for defining tests, integration with QuickCheck, SmallCheck, and HUnit, parallel test execution, and automatic discovery of test files.
Hpc: Haskell Program Coverage
Hpc is a tool-kit to record and display Haskell program coverage. Hpc includes tools that instrument Haskell programs to record program coverage, run instrumented programs, and display the coverage information obtained.
Haskell Equational Reasoning Assistant
Functional programmers often appeal to equational reasoning to justify various decisions made in both design and implementation. This page introduces the Haskell Equational Reasoning Assistant (HERA), an architecture that provides both a GUI level and a batch level Haskell rewrite engine inside a single tool.
pQC: parallel QuickCheck
pqc provides Test.QuickCheck.Parallel, a QuickCheck driver that runs jobs in parallel, and will utilise as many cores as you wish, with the SMP parallel GHC 6.6 runtime. It is simple, scalable replacement for Test.QuickCheck.Batch.

Debugging

highWaterMark
A library for determining the amount of memory allocated at any point by a GHC program.
GHC Internals library
A GHC library for polymorphically deconstructing heap objects from within Haskell code.
GHC Heap and Stable Table Printing library
Two libraries for GHC. The first is for printing heap objects from within Haskell or C code. The second is for dumping the contents of the Stable Table which is used for Stable Pointers and Stable Names.
LocH
Located errors, tracing and exceptions in Haskell.

Formal methods

Haskell98 termination analyzer
Checks termination of given start terms w.r.t. a Haskell program:
Retrieved from "https://wiki.haskell.org/index.php?title=Applications_and_libraries/Program_development&oldid=65318"