Awesome

Eta Hackage

This repository contains a set of patches for particular packages from Hackage that cannot be built out-of-the-box with etlas. Packages are automatically installed when you add them as a dependency to your project.

If a patch is in the repo, but your local etlas in unable to find a patch for it, run

etlas update

and try the installation again.

Table of Contents

Package Categorization
Contributing
- Patching a Library
  - Prerequisites
  - Patching

Package Categorization

Overview

We have categorized the packages from Hackage below in relation to etlas support. If a package from Hackage has not been listed here, it means no one has tried to build it and categorize it.

If you would like to have a given package/version made compatible with etlas, you can:

Submit an issue
Ask us on Gitter

Supported Packages

These packages are supported by etlas.

Web Development

Authentication

Compilers

Data Structures

Parallel Computing

Animations

active-0.2.0.13

Math & Abstractions

AWS

Incremental Computing

Adaptive-0.1

JSON

Simulation

Time

Developer Tools

Network

Command Line

DevOps

Concurrent Computing

Data Streaming

Data Serialization

avro-0.3.2.0

Data Manipulation

Base Libraries

Algorithms

Foreign Function Interface

bindings-DSL-1.0.23

Heuristics

Binpack-0.4.1

Compression

Graphics

Distributed Computing

Benchmarks

Blockchain

blockchain-0.0.3

Bytestring

Cryptography

Files

Error Handling

errors >= 2.1.3 && <= 2.2.2

Text

Testing

Database

Memory

Pretty Printers

System

Metaprogramming

Generic Programming

generics-sop-0.3.2.0

Audio

cue-sheet-1.0.1

Uncategorized

Unsupported Packages

These packages are heavy on FFI dependencies and don't make sense in the context of the JVM, hence no effort will be made to port them.

None for now

Built-in Packages

These packages have special meaning in the Eta compiler and hence are provided upon installation.

base-4.8.2.0
integer-0.5.1.0
- NOTE: Due to the drastic differences between the Integer implementations, the public API between the corresponding GHC package is slightly different.
ghc-prim-0.4.0.0
- NOTE: Due to the introduction of new primitives for Eta, the public API between the corresponding GHC package is slightly different.

Contributing

Patching a Library

Suppose that you find a library you want to patch or fix an existing patch, say somepackage-0.1.2.3.

Prerequisites

If you have already forked this repository, then skip to step 3.

Fork this repository.

Clone the forked repository.

git clone http://github.com/your-name-here/eta-hackage

Checkout the master branch and pull any changes.
```
git checkout master
git pull
```
Create a new branch with the same name as the package.
```
$ git checkout -b somepackage
```

Patching

Fetch the package and navigate to it.

etlas get somepackage-0.1.2.3
cd somepackage-0.1.2.3/

If the message "Found patch in eta-hackage for somepackage-0.1.2.3" appeared in step 1, skip to step 3.

Otherwise, initialize a Git repository and make an initial commit.
```
git init && git add . && git commit -m "First"
```
Build the package.
```
etlas build
```
If the previous version of the package has already been patched, try out:
```
git apply --reject [path-to-patch]
```
This will work in most cases. If not, resolve the changes.
Otherwise, apply the desired changes and go back to step 3 as long as the build fails.

Once the build succeeds, make a commit.

rm -rf dist/ && git add . && git commit -m "Patched"

Create a patch.

Mac and Linux users can use the following command to patch:
```
git format-patch HEAD~ --stdout > somepackage-0.1.2.3.patch
```
Windows users can use the following command to patch:
```
git format-patch HEAD~ --stdout --ignore-cr-at-eol > somepackage-0.1.2.3.patch
```
It had been detected that in windows patches created using powershell has not the correct format and can't be applied so it's better to do it in the dos console.
If you have changed the .cabal file of the package in your patch, make a copy and rename it from somepackage.cabal to somepackage-0.1.2.3.cabal.
```
cp somepackage.cabal somepackage-0.1.2.3.cabal
```
Copy the patch file and the cabal file (if changed) to the patches directory in your local clone of your fork of the eta-hackage repository.

NOTE: $YOUR_FORK_PATH should be replaced with the path to the local clone of your forked version of eta-hackage.

If the cabal file didn't change:
```
cp somepackage-0.1.2.3.patch $YOUR_FORK_PATH/patches/
```
If the cabal file changes:
```
cp somepackage-0.1.2.3.cabal somepackage-0.1.2.3.patch $YOUR_FORK_PATH/patches/
```
Update this README.md with the package name (in alphabetical order) in the Supported Packages section in the same format as the other packages.

If there already exists an entry for an older or newer version of the package, please consolidate the new versions into the existing entry. You can see the directory entry as an example.

In your eta-hackage repository,

$ git add .
$ git commit -m "Patched somepackage-0.1.2.3"
$ git push origin

Submit a pull request to this repository for review.

Applying an Existing Patch

If you want to apply the patch to an old version of a package to a new version of a package, you can run

git apply --ignore-space-change --ignore-whitespace --reject [location-of-patch]