The standard ways to install the Glasgow Haskell Compiler and related tools are given at the main Haskell webpage. However, there are many other ways to install GHC, suited for different purposes.
An IDE for Haskell featuring rapid-feedback playgrounds. Ideal for learning Haskell, experimentation, and for rapidly developing small Haskell applications. Haskell for Mac is a tool in the Integrated Development Environment category of a tech stack. Haskell for Mac vs NetBeans IDE: What are the differences? Haskell for Mac: An IDE for Haskell.An IDE for Haskell featuring rapid-feedback playgrounds. Ideal for learning Haskell, experimentation, and for rapidly developing small Haskell applications; NetBeans IDE: Quickly and easily develop desktop, mobile and web applications with Java, HTML5, PHP, C/C and more.
Haskell for Mac IDE
Haskell for Mac is an easy-to-use integrated programming environment for Haskell on OS X. It is a one-click install of a complete Haskell system, including Haskell compiler, editor, many libraries, and a novel form of interactive Haskell playgrounds. Haskell playgrounds support exploration and experimentation with code. They are convenient to learn functional programming, prototype Haskell code, interactively visualize data, and to create interactive animations.
Features include the following:
- Avoid dealing with complicated installation instructions.
- Built-in Haskell editor with customisable themes and context-sensitive identifier completion.
- Interactive Haskell playgrounds provide immediate and continuous feedback.
- You can immediately see what you program is doing while you develop it.
- Playground results can be text or images produced by the Rasterific, Diagrams, and Chart packages.
- Add code and multimedia files to a Haskell project with drag'n'drop.
- Haskell binding to Apple's 2D animation and games framework SpriteKit.
Haskell for Mac requires OS X Yosemite or above.
Nix Package Manager
The Nix package manager (part of NixOS but usable independently) can install GHC, related tools, and Haskell packages across Linux and other Unix systems (including OS X).
The key advantages of adopting Nix as a Haskell distribution are isolation and reproducibility, with environments fully specified. This can simplify dependency management by reducing hidden state.
The users' guide to Haskell infrastructure is the most important reference:http://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure
Also helpful are blog posts of and articles of various users describing their environments:
Nix support for Haskell is very much under active development, and many users have begun to adopt the new haskell-ng workflow: http://stackoverflow.com/questions/29033580/how-do-i-use-the-new-haskell-ng-infrastructure-on-nixos
Halcyon
Halcyon is a system for installing Haskell apps and development tools, including GHC and Cabal. It is a simple system which also archives and caches all build products, and can automatically restore archived build products, saving time during development, continuous integration, and deployment. It allows sandbox sources, build tools, and native OS packages to be declared as dependencies and installed together with the app. It can be used to construct deployment systems, such as Haskell on Heroku.
SageMathCloud
SageMathCloud is a platform for collaborative computational mathematics. It provides both free and paid accounts. Among the many tools it provides (including SageMath, R, IPython, Numpy/Scipy/Matplotlib, Octave, Cython, GAP, Pari, Macaulay2, and Singular) is GHC. It allows the editing of Haskell files and the creation of Haskell projects, and interaction with GHC through an embedded terminal in the command line.
With SageMathCloud, developers have access to a shared cloud environment for Haskell, usable from any computer with an internet connection, and requiring no installation.
Other Online Evaluators
There are other tools available that allow the compilation and execution of small amounts of Haskell code for testing, illustration and education purposes. These include:
Additionally, FP Complete's School of Haskell allows the embedding of 'active' example source code into their blog posts and tutorials.
In the last year or so, I haven't actually written as much Haskell as I'd like to. There are a few reasons for this. First, I switched to a non-Haskell job, meaning I was now using my Windows laptop for all my Haskell coding. Even on my previous work laptop (a Mac), things weren't easy. Haskell doesn't have a real IDE, like IntelliJ for Java or XCode for iOS development.
Besides not having an IDE, Windows presents extra pains compared to the more developer-friendly Mac. And it finally dawned on me. If I, as an experienced developer, was having this much friction, it must be a nightmare for beginners. Many people must be trying to both learn the language AND fight against their dev setup. So I decided to take some time to improve how I program so that it'll be easier for me to actually do it.
I wanted good general functionality, but also some Haskell-specific functions. I did a decent amount of research and settled on Atom as my editor of choice. In this article, we'll explore the basics of setting up Atom, what it offers, and the Haskell tools we can use within it. If you're just starting out with Haskell, I hope you can take these tips to make your Haskell Journey easier.
Note that many tips in this article won't work without the Haskell platform! To start with Haskell, download our Beginners Checklist, or read our Liftoff Series!
Goals
It's always good to begin with the end in mind. So before we start out, let's establish some goals for our development environment. A lot of these are basic items we should have regardless of what language we're using.
- Autocomplete. Must have for terms within the file. Nice to have for extra library functions and types.
- Syntax highlighting.
- Should be able to display at least two code files side-by-side, should also be able to open extra files in tabs.
- Basic file actions should only need the keyboard. These include opening new files to new tabs or splitting the window and opening a new file in the pane.
- Should be able to build code using the keyboard only. Should be able to examine terminal output and code at the same time.
- Should be able to format code automatically (using, for instance, Hindent)
- Some amount of help filling in library functions and basic types. Should be able to coordinate types from other files.
- Partial compilation. If I make an obvious mistake, the IDE should let me know immediately.
- Vim keybindings (depends on your preference of course)
With these goals in mind, let's go ahead and see how Atom can help us.
Basics of Atom
Luckily, the installation process for Atom is pretty painless. Using the Windows installer comes off without a hitch for me. Out of the box, Atom fulfills most of the basic requirements we'd have for an IDE. In fact, we get all our 1-4 goals without putting in any effort. The trick is that we have to learn a few keybindings. The following are what you'll need to open files.
- Ctrl+P - Open a new tab with a file using fuzzy find
- Ctrl+K + Direction (left/right/up/down arrow) - Open a new pane (will initially have the same file as before).
- Ctrl+K + Ctrl+Direction - Switch pane focus
Those commands solve requirements 3 and 4 from our goals list.
Another awesome thing about Atom is the extensive network of easy-to-install plugins. We'll look at some Haskell specific items below. But to start, we can use the package manager to install vim-mode-improved. This allows most Vim keybindings, fulfilling requirement 9 from above. There are a few things to re-learn with different keystrokes, but it works all right.
Adding Our Own Keybindings
Since Atom is so Hackable, you can also add your own keybindings and change ones you don't like. We'll do one simple example here, but you can also check out the documentation for some more ideas. One thing we'll need for goal #5 is to make it easier to bring up the bottom panel within atom. This is where terminal output goes when we run a command. You'll first want to open up keymap.cson, which you can do by going to the file menu and click Keymap….
Then you can add the following lines at the bottom:
First, we scope the command to the entire atom workspace. (We'll see an example below of a command with a more limited scope). Then we assign the Ctrl+Shift+Down Arrow key combination to toggle the bottom dock. Since it's a toggle command, we could repeat the command to move it both up and down. But this isn't very intuitive, so we add the second line so that we can also use the up arrow to bring it up.
A super helpful tool is the key binding resolver. At any point, you can use ctrl+. (control key plus the period key) to bring up the resolver. Then pressing any key combination will bring up the commands Atom will run for it. It will highlight the one it will pick in case of conflicts. This is great for finding unassigned key combinations!
Haskell Mode in Atom
Now let's start looking at adding some Haskell functionality to our editor. We'll start by installing a few different Haskell-related packages in Atom. You don't need all these, but this is a list of the core packages suggested in the Atom documentation.
The trickier part of getting Haskell functionality is the binary dependencies. A couple of the packages we added depend on having a couple programs installed. The most prominent of these is ghc-mod, which exposes some functionality of GHC. You'll also want a code formatter, such as hindent, or stylish-haskell installed.
At the most basic level, it's easy to install these programs with Stack. You can run the command:
Haskell Ide For Mac Catalina
However, ghc-mod matches up with a specific version of GHC. The command above installs the binaries at a system-wide level. This means you can only have the version for one GHC version installed at a time. So imagine you have one project using GHC 8.0, and another project using GHC 8.2. You won't be able to get Haskell features for each one at the same time using this approach. You would need to re-install the proper version whenever you switched projects.
As a note, there are a couple ways to ensure you know what version you've installed. First, you can run the stack install ghc-mod command from within the particular project directory. This will use that project's LTS to resolve which version you need. You can also modify the install command like so:
There is an approach where you can install different, compiler specific versions of the binary on your system, and have Atom pick the correct one. I haven't been able to make this approach work yet. But you can read about that approach on Alexis King's blog post here.
Keybinding for Builds
Once we have that working, we'll have met most of our feature goals. We'll have partial compilation and some Haskell specific autocompletion. There are other packages, such as haskell-hoogle that you can install for even more features.
There's one more feature we want though, which is to be able to build our project from the keyboard. When we installed our Haskell packages, Atom added a 'Haskell IDE' menu at the top. We can use this to build our project with 'Haskell IDE' -> 'Builder' -> 'Build Project'. We can add a keybinding for this command like so.
Notice that we added a namespace here, so this command will only run on Haskell files. Now we can build our project at any time with Ctrl+Shift+Alt+B, which will really streamline our development!
Weaknesses
The biggest weakness with Atom Haskell-mode is binary dependencies and GHC versions. The idea behind Stack is that switching to a different project with a different compiler shouldn't be hard. But there are a lot of hoops to jump through to get editor support. To be fair though, these problems are not exclusive to Atom.
Another weakness is that the Haskell plugins for Atom currently only support up through LTS 9 (GHC 8). This is a big weakness if you're looking to use new features from the cutting edge of GHC development. So Atom Haskell-mode might not be fully-featured for industry projects or experimental work.
As a further note, the Vim mode in Atom doesn't give all the keybindings you might expect from Vim. For example, I could no longer use the colon key plus a number to jump to a line. Of course, Atom has its own bindings for these things. But it takes a little while to re-learn the muscle memory.
Alternatives
Haskell Ide For Mac Os
There are, of course, alternatives to the approach I've laid out in this article. Many plugins/packages exist enabling you to get good Haskell features with Emacs and Vim. For Emacs, you should look at haskell-mode. For Vim, I made the most progress following this article from Stephen Diehl. I'll say for my part that I haven't tried the Emacs approach, and ran into problems a couple times with Vim. But with enough time and effort, you can get them to work!
If you use Visual Studio, there are a couple packages for Haskell: Haskelly and Haskero. I haven't used either of these, but they both seem provide a lot of nice features.
Conclusion
Having a good development environment is one of the keys to programming success. More popular languages have full-featured IDE's that make programming a lot easier. Haskell doesn't have this level of support. But there's enough community help that you can use a hackable editor like Atom to get most of what you want. Since I fixed this glaring weakness, I've been able to write Haskell much more efficiently. If you're starting out with the language, this can make or break your experience! So it's worth investing at least a little bit of time and effort to ensure you've got a smooth system to work with.
Haskell Ide For Mac Operating System
Of course, having an editor setup for Haskell is meaningless if you've never used the language! Download our Beginners Checklist or read our Liftoff Series to get going!