Commit | Line | Data |
---|---|---|
804744b3 | 1 | ;;; GNU Guix --- Functional package management for GNU |
62e42dfa | 2 | ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu> |
804744b3 LC |
3 | ;;; Copyright © 2015, 2017, 2018 Ricardo Wurmus <rekado@elephly.net> |
4 | ;;; Copyright © 2016, 2017, 2018 ng0 <ng0@n0.is> | |
62e42dfa RV |
5 | ;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org> |
6 | ;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com> | |
804744b3 LC |
7 | ;;; Copyright © 2017, 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr> |
8 | ;;; Copyright © 2018 Timothy Sample <samplet@ngyro.com> | |
9 | ;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net> | |
10 | ;;; Copyright © 2016, 2017 Leo Famulari <leo@famulari.name> | |
bfccae4e | 11 | ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> |
3d45d8f1 | 12 | ;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com> |
6ec2450f | 13 | ;;; Copyright © 2015 John Soo <jsoo1@asu.edu> |
ac1b0801 | 14 | ;;; Copyright © 2019 Efraim Flashner <efraim@flashner.co.il> |
51add2a9 | 15 | ;;; Copyright © 2019 Alex Griffin <a@ajgrf.com> |
eea58169 | 16 | ;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org> |
79617a01 | 17 | ;;; Copyright © 2020 Brian Leung <bkleung89@gmail.com> |
804744b3 LC |
18 | ;;; |
19 | ;;; This file is part of GNU Guix. | |
20 | ;;; | |
21 | ;;; GNU Guix is free software; you can redistribute it and/or modify it | |
22 | ;;; under the terms of the GNU General Public License as published by | |
23 | ;;; the Free Software Foundation; either version 3 of the License, or (at | |
24 | ;;; your option) any later version. | |
25 | ;;; | |
26 | ;;; GNU Guix is distributed in the hope that it will be useful, but | |
27 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
28 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
29 | ;;; GNU General Public License for more details. | |
30 | ;;; | |
31 | ;;; You should have received a copy of the GNU General Public License | |
32 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. | |
33 | ||
34 | (define-module (gnu packages haskell-apps) | |
35 | #:use-module (guix download) | |
62e42dfa | 36 | #:use-module (guix git-download) |
804744b3 LC |
37 | #:use-module (guix packages) |
38 | #:use-module ((guix licenses) #:prefix license:) | |
39 | #:use-module (guix build-system haskell) | |
40 | #:use-module (gnu packages base) | |
41 | #:use-module (gnu packages curl) | |
bfccae4e | 42 | #:use-module (gnu packages gl) |
804744b3 LC |
43 | #:use-module (gnu packages haskell) |
44 | #:use-module (gnu packages haskell-check) | |
45 | #:use-module (gnu packages haskell-crypto) | |
46 | #:use-module (gnu packages haskell-web) | |
dddbc90c | 47 | #:use-module (gnu packages haskell-xyz) |
804744b3 LC |
48 | #:use-module (gnu packages ncurses) |
49 | #:use-module (gnu packages perl) | |
50 | #:use-module (gnu packages pkg-config) | |
51 | #:use-module (gnu packages rsync) | |
52 | #:use-module (gnu packages version-control)) | |
53 | ||
79617a01 BL |
54 | (define-public apply-refact |
55 | (package | |
56 | (name "apply-refact") | |
57 | (version "0.6.0.0") | |
58 | (source | |
59 | (origin | |
60 | (method url-fetch) | |
61 | (uri (string-append | |
62 | "https://hackage.haskell.org/package/apply-refact/apply-refact-" | |
63 | version ".tar.gz")) | |
64 | (sha256 | |
65 | (base32 | |
66 | "0p2mqgjcqr1zcmk8zgr0yq7g8z1agsa6l493lkj6g3ya9lyhxgig")))) | |
67 | (build-system haskell-build-system) | |
68 | (inputs | |
69 | `(("ghc-refact" ,ghc-refact) | |
70 | ("ghc-exactprint" ,ghc-exactprint) | |
71 | ("ghc-syb" ,ghc-syb) | |
72 | ("ghc-temporary" ,ghc-temporary) | |
73 | ("ghc-filemanip" ,ghc-filemanip) | |
74 | ("ghc-unix-compat" ,ghc-unix-compat) | |
75 | ("ghc-optparse-applicative" | |
76 | ,ghc-optparse-applicative))) | |
77 | (native-inputs | |
78 | `(("ghc-tasty" ,ghc-tasty) | |
79 | ("ghc-tasty-golden" ,ghc-tasty-golden) | |
80 | ("ghc-tasty-expected-failure" | |
81 | ,ghc-tasty-expected-failure) | |
82 | ("ghc-silently" ,ghc-silently))) | |
83 | (home-page "https://hackage.haskell.org/package/apply-refact") | |
84 | (synopsis "Perform refactorings specified by the refact library") | |
85 | (description | |
86 | "This package lets you perform refactorings specified by the refact | |
87 | library. It is primarily used with HLint's @code{--refactor} flag.") | |
88 | (license license:bsd-3))) | |
89 | ||
841f1954 TS |
90 | ;; In Stackage LTS 14, this package is at 2.4.1.0. However, that |
91 | ;; version requires version 2.4.1.0 of the 'Cabal' package, which is | |
92 | ;; provided by GHC 8.6.5 at version 2.4.0.1. Hence, we use an older | |
93 | ;; version to match the compiler's library. | |
62e42dfa RV |
94 | (define-public cabal-install |
95 | (package | |
96 | (name "cabal-install") | |
841f1954 | 97 | (version "2.4.0.0") |
62e42dfa RV |
98 | (source |
99 | (origin | |
100 | (method url-fetch) | |
101 | (uri (string-append | |
102 | "https://hackage.haskell.org/package/cabal-install/cabal-install-" | |
103 | version | |
104 | ".tar.gz")) | |
105 | (sha256 | |
841f1954 | 106 | (base32 "1xmyl0x8wqfrnray6ky5wy0g0samv4264fbdlzxhqsvk9dbfja8k")))) |
62e42dfa | 107 | (build-system haskell-build-system) |
841f1954 TS |
108 | (arguments |
109 | `(#:cabal-revision | |
110 | ("2" "1xil5pim6j1ckqj61zz6l7xpfxxr3rkw2hvpws2f7pr9shk645dl") | |
111 | #:phases | |
112 | (modify-phases %standard-phases | |
113 | (add-before 'configure 'update-constraints | |
114 | (lambda _ | |
115 | (substitute* "cabal-install.cabal" | |
116 | (("zip-archive >= 0\\.3\\.2\\.5 && < 0\\.4,") | |
117 | "zip-archive >= 0.3.2.5 && <= 0.4.1,")) | |
118 | #t))))) | |
62e42dfa RV |
119 | (inputs |
120 | `(("ghc-async" ,ghc-async) | |
121 | ("ghc-base16-bytestring" ,ghc-base16-bytestring) | |
122 | ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256) | |
123 | ("ghc-echo" ,ghc-echo) | |
124 | ("ghc-edit-distance" ,ghc-edit-distance) | |
125 | ("ghc-hackage-security" ,ghc-hackage-security) | |
126 | ("ghc-hashable" ,ghc-hashable) | |
127 | ("ghc-http" ,ghc-http) | |
128 | ("ghc-network-uri" ,ghc-network-uri) | |
129 | ("ghc-network" ,ghc-network) | |
130 | ("ghc-random" ,ghc-random) | |
131 | ("ghc-resolv" ,ghc-resolv) | |
132 | ("ghc-tar" ,ghc-tar) | |
841f1954 | 133 | ("ghc-zip-archive" ,ghc-zip-archive) |
62e42dfa RV |
134 | ("ghc-zlib" ,ghc-zlib))) |
135 | (home-page "https://www.haskell.org/cabal/") | |
136 | (synopsis "Command-line interface for Cabal and Hackage") | |
137 | (description | |
138 | "The cabal command-line program simplifies the process of managing | |
139 | Haskell software by automating the fetching, configuration, compilation and | |
140 | installation of Haskell libraries and programs.") | |
141 | (license license:bsd-3))) | |
142 | ||
143 | (define-public corrode | |
144 | (let ((commit "b6699fb2fa552a07c6091276285a44133e5c9789")) | |
145 | (package | |
146 | (name "corrode") | |
147 | (version (string-append "0.0.1-" (string-take commit 7))) | |
148 | (source | |
149 | (origin | |
150 | (method git-fetch) | |
151 | (uri (git-reference | |
152 | (url "https://github.com/jameysharp/corrode.git") | |
153 | (commit "b6699fb2fa552a07c6091276285a44133e5c9789"))) | |
bb90beb5 | 154 | (file-name (git-file-name name version)) |
62e42dfa RV |
155 | (sha256 |
156 | (base32 "02v0yyj6sk4gpg2222wzsdqjxn8w66scbnf6b20x0kbmc69qcz4r")))) | |
157 | (build-system haskell-build-system) | |
158 | (inputs | |
159 | `(("ghc-language-c" ,ghc-language-c) | |
160 | ("ghc-markdown-unlit" ,ghc-markdown-unlit))) | |
161 | (home-page "https://github.com/jameysharp/corrode") | |
162 | (synopsis "Automatic semantics-preserving translation from C to Rust") | |
163 | (description | |
164 | "This program reads a C source file and prints an equivalent module in | |
165 | Rust syntax. It is intended to be useful for two different purposes: | |
166 | ||
167 | @enumerate | |
168 | @item Partial automation for migrating legacy code that was implemented in C. | |
169 | @item A new, complementary approach to static analysis for C programs. | |
170 | @end enumerate\n") | |
171 | (license license:gpl2+)))) | |
172 | ||
173 | (define-public cpphs | |
174 | (package | |
175 | (name "cpphs") | |
176 | (version "1.20.8") | |
177 | (source | |
178 | (origin | |
179 | (method url-fetch) | |
180 | (uri (string-append | |
181 | "https://hackage.haskell.org/package/" name "/" | |
182 | name "-" version ".tar.gz")) | |
183 | (sha256 | |
184 | (base32 | |
185 | "1bh524asqhk9v1s0wvipl0hgn7l63iy3js867yv0z3h5v2kn8vg5")))) | |
186 | (build-system haskell-build-system) | |
187 | (inputs | |
188 | `(("ghc-polyparse" ,ghc-polyparse) | |
189 | ("ghc-old-locale" ,ghc-old-locale) | |
190 | ("ghc-old-time" ,ghc-old-time))) | |
191 | (home-page "http://projects.haskell.org/cpphs/") | |
192 | (synopsis "Liberalised re-implementation of cpp, the C pre-processor") | |
193 | (description "Cpphs is a re-implementation of the C pre-processor that is | |
194 | both more compatible with Haskell, and itself written in Haskell so that it | |
195 | can be distributed with compilers. This version of the C pre-processor is | |
196 | pretty-much feature-complete and compatible with traditional (K&R) | |
197 | pre-processors. Additional features include: a plain-text mode; an option to | |
198 | unlit literate code files; and an option to turn off macro-expansion.") | |
199 | (license (list license:lgpl2.1+ license:gpl3+)))) | |
200 | ||
804744b3 LC |
201 | ;; Darcs has no https support: http://irclog.perlgeek.de/darcs/2016-09-17 |
202 | ;; http://darcs.net/manual/Configuring_darcs.html#SECTION00440070000000000000 | |
203 | ;; and results of search engines will show that if the protocol is http, https | |
204 | ;; is never mentioned. | |
205 | (define-public darcs | |
206 | (package | |
207 | (name "darcs") | |
208 | (version "2.14.2") | |
209 | (source | |
210 | (origin | |
211 | (method url-fetch) | |
212 | (uri (string-append "https://hackage.haskell.org/package/darcs/" | |
213 | "darcs-" version ".tar.gz")) | |
214 | (sha256 | |
215 | (base32 | |
216 | "0zm2486gyhiga1amclbg92cd09bvki6vgh0ll75hv5kl72j61lb5")) | |
217 | (modules '((guix build utils))) | |
218 | ;; Remove time-dependent code for reproducibility. | |
219 | (snippet | |
220 | '(begin | |
221 | (substitute* "darcs/darcs.hs" | |
222 | (("__DATE__") "\"1970-01-01\"") | |
223 | (("__TIME__") "\"00:00:00\"")) | |
224 | #t)))) | |
225 | (build-system haskell-build-system) | |
226 | (arguments | |
0710797d TS |
227 | `(#:cabal-revision |
228 | ("1" "0xl7j5cm704pbl2ms0dkydh7jvrz0ym76d725ifpg4h902m1zkhg") | |
229 | #:configure-flags '("-fpkgconfig" "-fcurl" "-flibiconv" "-fthreaded" | |
804744b3 LC |
230 | "-fnetwork-uri" "-fhttp" "--flag=executable" |
231 | "--flag=library") | |
232 | #:phases | |
233 | (modify-phases %standard-phases | |
234 | (add-after 'patch-source-shebangs 'patch-sh | |
235 | (lambda _ | |
236 | (substitute* "tests/issue538.sh" | |
237 | (("/bin/sh") (which "sh"))) | |
0710797d TS |
238 | #t)) |
239 | (add-before 'configure 'update-constraints | |
240 | (lambda _ | |
241 | (substitute* "darcs.cabal" | |
242 | (("QuickCheck >= 2\\.8\\.2 && < 2\\.13,") | |
243 | "QuickCheck >= 2.8.2 && < 2.14,")) | |
804744b3 LC |
244 | #t))))) |
245 | (inputs | |
246 | `(("ghc-cmdargs" ,ghc-cmdargs) | |
247 | ("ghc-split" ,ghc-split) | |
248 | ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) | |
249 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) | |
250 | ("ghc-test-framework" ,ghc-test-framework) | |
251 | ("ghc-quickcheck" ,ghc-quickcheck) | |
252 | ("ghc-findbin" ,ghc-findbin) | |
253 | ("ghc-hunit" ,ghc-hunit) | |
254 | ("ghc-async" ,ghc-async) | |
255 | ("ghc-attoparsec" ,ghc-attoparsec) | |
256 | ("ghc-base16-bytestring" ,ghc-base16-bytestring) | |
257 | ("ghc-bytestring-builder" ,ghc-bytestring-builder) | |
258 | ("ghc-cryptohash" ,ghc-cryptohash) | |
259 | ("ghc-data-ordlist" ,ghc-data-ordlist) | |
260 | ("ghc-fgl" ,ghc-fgl) | |
261 | ("ghc-system-filepath" ,ghc-system-filepath) | |
262 | ("ghc-graphviz" ,ghc-graphviz) | |
263 | ("ghc-hashable" ,ghc-hashable) | |
264 | ("ghc-html" ,ghc-html) | |
265 | ("ghc-mmap" ,ghc-mmap) | |
266 | ("ghc-old-time" ,ghc-old-time) | |
804744b3 LC |
267 | ("ghc-random" ,ghc-random) |
268 | ("ghc-regex-applicative" ,ghc-regex-applicative) | |
269 | ("ghc-regex-compat-tdfa" ,ghc-regex-compat-tdfa) | |
270 | ("ghc-sandi" ,ghc-sandi) | |
271 | ("ghc-shelly" ,ghc-shelly) | |
272 | ("ghc-tar" ,ghc-tar) | |
273 | ("ghc-transformers-compat" ,ghc-transformers-compat) | |
274 | ("ghc-unix-compat" ,ghc-unix-compat) | |
275 | ("ghc-utf8-string" ,ghc-utf8-string) | |
276 | ("ghc-vector" ,ghc-vector) | |
277 | ("ghc-zip-archive" ,ghc-zip-archive) | |
278 | ("ghc-zlib" ,ghc-zlib) | |
279 | ("ghc-http" ,ghc-http) | |
280 | ("curl" ,curl) | |
281 | ("ghc" ,ghc) | |
282 | ("ncurses" ,ncurses) | |
283 | ("perl" ,perl) | |
284 | ("libiconv" ,libiconv) | |
285 | ("ghc-network" ,ghc-network) | |
286 | ("ghc-network-uri" ,ghc-network-uri))) | |
287 | (native-inputs | |
288 | `(("pkg-config" ,pkg-config))) | |
289 | (home-page "http://darcs.net") | |
290 | (synopsis "Distributed Revision Control System") | |
291 | (description | |
292 | "Darcs is a revision control system. It is: | |
293 | ||
294 | @enumerate | |
295 | @item Distributed: Every user has access to the full command set, removing boundaries | |
296 | between server and client or committer and non-committers. | |
297 | @item Interactive: Darcs is easy to learn and efficient to use because it asks you | |
298 | questions in response to simple commands, giving you choices in your work flow. | |
299 | You can choose to record one change in a file, while ignoring another. As you update | |
300 | from upstream, you can review each patch name, even the full diff for interesting | |
301 | patches. | |
302 | @item Smart: Originally developed by physicist David Roundy, darcs is based on a | |
303 | unique algebra of patches called @url{http://darcs.net/Theory,Patchtheory}. | |
304 | @end enumerate") | |
305 | (license license:gpl2))) | |
306 | ||
eea58169 ASM |
307 | (define-public ghcid |
308 | (package | |
309 | (name "ghcid") | |
310 | (version "0.8.4") | |
311 | (source | |
312 | (origin | |
313 | (method url-fetch) | |
314 | (uri (string-append "https://hackage.haskell.org/package/ghcid/" | |
315 | "ghcid-" version ".tar.gz")) | |
316 | (sha256 | |
317 | (base32 | |
318 | "0wpm4ikrm1krz1ckzwk0srng091yh2skjal4fh95iz1hq3dw6qlw")))) | |
319 | (build-system haskell-build-system) | |
320 | (inputs | |
321 | `(("ghc-extra" ,ghc-extra) | |
322 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) | |
323 | ("ghc-cmdargs" ,ghc-cmdargs) | |
324 | ("ghc-fsnotify" ,ghc-fsnotify) | |
325 | ("ghc-terminal-size" ,ghc-terminal-size))) | |
326 | (native-inputs | |
327 | `(("ghc-tasty" ,ghc-tasty) | |
328 | ("ghc-tasty-hunit" ,ghc-tasty-hunit))) | |
329 | (home-page | |
330 | "https://github.com/ndmitchell/ghcid#readme") | |
331 | (synopsis "GHCi based bare bones IDE") | |
332 | (description | |
333 | "Either \"GHCi as a daemon\" or \"GHC + a bit of an IDE\". A very simple Haskell | |
334 | development tool which shows you the errors in your project and updates them whenever | |
335 | you save. Run @code{ghcid --topmost --command=ghci}, where @code{--topmost} makes the | |
336 | window on top of all others (Windows only) and @code{--command} is the command to start | |
337 | GHCi on your project (defaults to @code{ghci} if you have a @file{.ghci} file, or else | |
338 | to @code{cabal repl}).") | |
339 | (license license:bsd-3))) | |
340 | ||
804744b3 LC |
341 | (define-public git-annex |
342 | (package | |
343 | (name "git-annex") | |
9cbc5fae | 344 | (version "8.20200330") |
804744b3 LC |
345 | (source |
346 | (origin | |
347 | (method url-fetch) | |
348 | (uri (string-append "https://hackage.haskell.org/package/" | |
349 | "git-annex/git-annex-" version ".tar.gz")) | |
350 | (sha256 | |
9cbc5fae | 351 | (base32 "0xy0ld7kr4cfdl4g4yzvrzl5r60dcj33cxm28a4qz6nqm2yhd4sv")))) |
804744b3 LC |
352 | (build-system haskell-build-system) |
353 | (arguments | |
354 | `(#:configure-flags | |
ac1b0801 | 355 | '("--flags=-Android -Assistant -Pairing -Webapp -WebDAV") |
804744b3 LC |
356 | #:phases |
357 | (modify-phases %standard-phases | |
3d45d8f1 | 358 | (add-before 'configure 'patch-shell-for-tests |
804744b3 | 359 | (lambda _ |
3d45d8f1 KM |
360 | ;; Shell.hs defines "/bin/sh" that is used in Git hooks. We |
361 | ;; shouldn't patch hooks with Guix's current bash because the | |
362 | ;; hooks can exist after that bash is garbage collected, but | |
363 | ;; let's temporarily patch it so that we can run the tests. | |
364 | (copy-file "Utility/Shell.hs" "/tmp/Shell.hs") | |
804744b3 LC |
365 | (substitute* "Utility/Shell.hs" |
366 | (("/bin/sh") (which "sh"))) | |
367 | #t)) | |
368 | (add-before 'configure 'factor-setup | |
369 | (lambda _ | |
370 | ;; Factor out necessary build logic from the provided | |
371 | ;; `Setup.hs' script. The script as-is does not work because | |
372 | ;; it cannot find its dependencies, and there is no obvious way | |
373 | ;; to tell it where to look. Note that we do not preserve the | |
374 | ;; code that installs man pages here. | |
375 | (call-with-output-file "PreConf.hs" | |
376 | (lambda (out) | |
377 | (format out "import qualified Build.Configure as Configure~%") | |
378 | (format out "main = Configure.run Configure.tests~%"))) | |
379 | (call-with-output-file "Setup.hs" | |
380 | (lambda (out) | |
381 | (format out "import Distribution.Simple~%") | |
382 | (format out "main = defaultMain~%"))) | |
383 | #t)) | |
384 | (add-before 'configure 'pre-configure | |
385 | (lambda _ | |
386 | (invoke "runhaskell" "PreConf.hs") | |
387 | #t)) | |
388 | (replace 'check | |
389 | (lambda _ | |
390 | ;; We need to set the path so that Git recognizes | |
391 | ;; `git annex' as a custom command. | |
392 | (setenv "PATH" (string-append (getenv "PATH") ":" | |
393 | (getcwd) "/dist/build/git-annex")) | |
394 | (with-directory-excursion "dist/build/git-annex" | |
395 | (symlink "git-annex" "git-annex-shell")) | |
396 | (invoke "git-annex" "test") | |
397 | #t)) | |
3d45d8f1 KM |
398 | (add-after 'check 'unpatch-shell-and-rebuild |
399 | (lambda args | |
400 | ;; Undo `patch-shell-for-tests'. | |
401 | (copy-file "/tmp/Shell.hs" "Utility/Shell.hs") | |
402 | (apply (assoc-ref %standard-phases 'build) args))) | |
804744b3 LC |
403 | (add-after 'install 'install-symlinks |
404 | (lambda* (#:key outputs #:allow-other-keys) | |
405 | (let* ((out (assoc-ref outputs "out")) | |
406 | (bin (string-append out "/bin"))) | |
407 | (symlink (string-append bin "/git-annex") | |
408 | (string-append bin "/git-annex-shell")) | |
409 | (symlink (string-append bin "/git-annex") | |
410 | (string-append bin "/git-remote-tor-annex")) | |
411 | #t)))))) | |
412 | (inputs | |
413 | `(("curl" ,curl) | |
414 | ("ghc-aeson" ,ghc-aeson) | |
415 | ("ghc-async" ,ghc-async) | |
ac1b0801 | 416 | ("ghc-aws" ,ghc-aws) |
804744b3 LC |
417 | ("ghc-bloomfilter" ,ghc-bloomfilter) |
418 | ("ghc-byteable" ,ghc-byteable) | |
419 | ("ghc-case-insensitive" ,ghc-case-insensitive) | |
a4a41a7b | 420 | ("ghc-concurrent-output" ,ghc-concurrent-output) |
804744b3 LC |
421 | ("ghc-crypto-api" ,ghc-crypto-api) |
422 | ("ghc-cryptonite" ,ghc-cryptonite) | |
423 | ("ghc-data-default" ,ghc-data-default) | |
424 | ("ghc-disk-free-space" ,ghc-disk-free-space) | |
425 | ("ghc-dlist" ,ghc-dlist) | |
426 | ("ghc-edit-distance" ,ghc-edit-distance) | |
427 | ("ghc-esqueleto" ,ghc-esqueleto) | |
428 | ("ghc-exceptions" ,ghc-exceptions) | |
429 | ("ghc-feed" ,ghc-feed) | |
0e5c0e46 | 430 | ("ghc-filepath-bytestring" ,ghc-filepath-bytestring) |
804744b3 LC |
431 | ("ghc-free" ,ghc-free) |
432 | ("ghc-hslogger" ,ghc-hslogger) | |
433 | ("ghc-http-client" ,ghc-http-client) | |
434 | ("ghc-http-conduit" ,ghc-http-conduit) | |
435 | ("ghc-http-types" ,ghc-http-types) | |
436 | ("ghc-ifelse" ,ghc-ifelse) | |
f2a3ff85 | 437 | ("ghc-magic" ,ghc-magic) |
804744b3 LC |
438 | ("ghc-memory" ,ghc-memory) |
439 | ("ghc-monad-control" ,ghc-monad-control) | |
440 | ("ghc-monad-logger" ,ghc-monad-logger) | |
441 | ("ghc-network" ,ghc-network) | |
442 | ("ghc-old-locale" ,ghc-old-locale) | |
443 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
444 | ("ghc-persistent" ,ghc-persistent) | |
445 | ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) | |
446 | ("ghc-persistent-template" ,ghc-persistent-template) | |
447 | ("ghc-quickcheck" ,ghc-quickcheck) | |
448 | ("ghc-random" ,ghc-random) | |
449 | ("ghc-regex-tdfa" ,ghc-regex-tdfa) | |
450 | ("ghc-resourcet" ,ghc-resourcet) | |
451 | ("ghc-safesemaphore" ,ghc-safesemaphore) | |
452 | ("ghc-sandi" ,ghc-sandi) | |
453 | ("ghc-securemem" ,ghc-securemem) | |
454 | ("ghc-socks" ,ghc-socks) | |
455 | ("ghc-split" ,ghc-split) | |
804744b3 LC |
456 | ("ghc-stm-chans" ,ghc-stm-chans) |
457 | ("ghc-tagsoup" ,ghc-tagsoup) | |
804744b3 LC |
458 | ("ghc-unix-compat" ,ghc-unix-compat) |
459 | ("ghc-unordered-containers" ,ghc-unordered-containers) | |
460 | ("ghc-utf8-string" ,ghc-utf8-string) | |
461 | ("ghc-uuid" ,ghc-uuid) | |
462 | ("git" ,git) | |
463 | ("rsync" ,rsync))) | |
464 | (native-inputs | |
465 | `(("ghc-tasty" ,ghc-tasty) | |
466 | ("ghc-tasty-hunit" ,ghc-tasty-hunit) | |
467 | ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) | |
468 | ("ghc-tasty-rerun" ,ghc-tasty-rerun))) | |
469 | (home-page "https://git-annex.branchable.com/") | |
470 | (synopsis "Manage files with Git, without checking in their contents") | |
471 | (description "This package allows managing files with Git, without | |
472 | checking the file contents into Git. It can store files in many places, | |
473 | such as local hard drives and cloud storage services. It can also be | |
474 | used to keep a folder in sync between computers.") | |
7e772cb6 KM |
475 | ;; The main author has released all his changes under AGPLv3+ as of March |
476 | ;; 2019 (7.20190219-187-g40ecf58d4). These are also licensed under the | |
477 | ;; original GPLv3+ license, but going forward new changes will be under | |
478 | ;; only AGPLv3+. The other licenses below cover code written by others. | |
479 | ;; See git-annex's COPYRIGHT file for details on each file. | |
480 | (license (list license:agpl3+ | |
481 | license:gpl3+ | |
482 | license:bsd-2 | |
483 | license:expat | |
484 | license:gpl2)))) | |
bfccae4e | 485 | |
62e42dfa RV |
486 | (define-public hlint |
487 | (package | |
488 | (name "hlint") | |
cfbb0a95 | 489 | (version "2.1.26") |
62e42dfa RV |
490 | (source |
491 | (origin | |
492 | (method url-fetch) | |
493 | (uri (string-append | |
494 | "https://hackage.haskell.org/package/" name | |
495 | "/" name "-" version ".tar.gz")) | |
496 | (sha256 | |
497 | (base32 | |
cfbb0a95 | 498 | "16zkkpbfrd69853cdqf597fva969lirfc86b039i9zd7ghlrcayc")))) |
62e42dfa RV |
499 | (build-system haskell-build-system) |
500 | (inputs | |
501 | `(("cpphs" ,cpphs) | |
502 | ("ghc-unordered-containers" ,ghc-unordered-containers) | |
503 | ("ghc-yaml" ,ghc-yaml) | |
504 | ("ghc-vector" ,ghc-vector) | |
505 | ("ghc-data-default" ,ghc-data-default) | |
506 | ("ghc-cmdargs" ,ghc-cmdargs) | |
507 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
508 | ("ghc-haskell-src-exts-util" ,ghc-haskell-src-exts-util) | |
509 | ("ghc-uniplate" ,ghc-uniplate) | |
510 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) | |
511 | ("ghc-extra" ,ghc-extra) | |
512 | ("ghc-refact" ,ghc-refact) | |
513 | ("ghc-aeson" ,ghc-aeson) | |
cfbb0a95 | 514 | ("ghc-lib-parser" ,ghc-lib-parser) |
62e42dfa | 515 | ("hscolour" ,hscolour))) |
19115138 | 516 | (home-page "https://github.com/ndmitchell/hlint") |
62e42dfa RV |
517 | (synopsis "Suggest improvements for Haskell source code") |
518 | (description "HLint reads Haskell programs and suggests changes that | |
519 | hopefully make them easier to read. HLint also makes it easy to disable | |
520 | unwanted suggestions, and to add your own custom suggestions.") | |
521 | (license license:bsd-3))) | |
522 | ||
6ec2450f JS |
523 | (define-public hoogle |
524 | (package | |
525 | (name "hoogle") | |
12ee2d5d | 526 | (version "5.0.17.11") |
6ec2450f JS |
527 | (source |
528 | (origin | |
529 | (method url-fetch) | |
530 | (uri | |
531 | (string-append | |
532 | "https://hackage.haskell.org/package/hoogle/hoogle-" | |
533 | version ".tar.gz")) | |
534 | (sha256 | |
535 | (base32 | |
12ee2d5d | 536 | "1svp8z9pad8z2j386pr0dda0ds8ddxab0salnz4gm51q877w93p1")))) |
6ec2450f JS |
537 | (build-system haskell-build-system) |
538 | (inputs | |
12ee2d5d | 539 | `(("ghc-quickcheck" ,ghc-quickcheck) |
6ec2450f | 540 | ("ghc-aeson" ,ghc-aeson) |
12ee2d5d TS |
541 | ("ghc-blaze-html" ,ghc-blaze-html) |
542 | ("ghc-blaze-markup" ,ghc-blaze-markup) | |
6ec2450f JS |
543 | ("ghc-cmdargs" ,ghc-cmdargs) |
544 | ("ghc-conduit" ,ghc-conduit) | |
545 | ("ghc-conduit-extra" ,ghc-conduit-extra) | |
546 | ("ghc-connection" ,ghc-connection) | |
547 | ("ghc-extra" ,ghc-extra) | |
12ee2d5d | 548 | ("ghc-foundation" ,ghc-foundation) |
6ec2450f JS |
549 | ("ghc-old-locale" ,ghc-old-locale) |
550 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
551 | ("ghc-http-conduit" ,ghc-http-conduit) | |
552 | ("ghc-http-types" ,ghc-http-types) | |
553 | ("ghc-js-flot" ,ghc-js-flot) | |
554 | ("ghc-js-jquery" ,ghc-js-jquery) | |
555 | ("ghc-mmap" ,ghc-mmap) | |
556 | ("ghc-process-extras" ,ghc-process-extras) | |
557 | ("ghc-resourcet" ,ghc-resourcet) | |
558 | ("ghc-storable-tuple" ,ghc-storable-tuple) | |
559 | ("ghc-tar" ,ghc-tar) | |
560 | ("ghc-uniplate" ,ghc-uniplate) | |
561 | ("ghc-utf8-string" ,ghc-utf8-string) | |
562 | ("ghc-vector" ,ghc-vector) | |
563 | ("ghc-wai" ,ghc-wai) | |
564 | ("ghc-wai-logger" ,ghc-wai-logger) | |
565 | ("ghc-warp" ,ghc-warp) | |
566 | ("ghc-warp-tls" ,ghc-warp-tls) | |
567 | ("ghc-zlib" ,ghc-zlib))) | |
568 | (home-page "https://hoogle.haskell.org/") | |
569 | (synopsis "Haskell API Search") | |
570 | (description "Hoogle is a Haskell API search engine, which allows | |
571 | you to search many standard Haskell libraries by either function name, | |
572 | or by approximate type signature.") | |
573 | (license license:bsd-3))) | |
574 | ||
62e42dfa RV |
575 | (define-public hscolour |
576 | (package | |
577 | (name "hscolour") | |
578 | (version "1.24.4") | |
579 | (source | |
580 | (origin | |
581 | (method url-fetch) | |
582 | (uri (string-append | |
583 | "https://hackage.haskell.org/package/hscolour/hscolour-" | |
584 | version | |
585 | ".tar.gz")) | |
586 | (sha256 | |
587 | (base32 | |
588 | "079jwph4bwllfp03yfr26s5zc6m6kw3nhb1cggrifh99haq34cr4")))) | |
589 | (build-system haskell-build-system) | |
590 | (home-page "https://hackage.haskell.org/package/hscolour") | |
591 | (synopsis "Script to colourise Haskell code") | |
592 | (description "HSColour is a small Haskell script to colourise Haskell | |
593 | code. It currently has six output formats: ANSI terminal codes (optionally | |
594 | XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01 | |
595 | with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX, | |
596 | and mIRC chat codes.") | |
597 | (license license:bsd-3))) | |
598 | ||
51add2a9 AG |
599 | (define-public kmonad |
600 | (package | |
601 | (name "kmonad") | |
15c06ad0 | 602 | (version "0.3.0") |
51add2a9 AG |
603 | (source |
604 | (origin | |
605 | (method git-fetch) | |
606 | (uri (git-reference | |
607 | (url "https://github.com/david-janssen/kmonad.git") | |
15c06ad0 | 608 | (commit version))) |
51add2a9 AG |
609 | (file-name (git-file-name name version)) |
610 | (sha256 | |
15c06ad0 | 611 | (base32 "1g40nkpldih6h1rlxjx5yf9iavr3qs1f2b6j0gd8135p5hkg8d8n")))) |
51add2a9 AG |
612 | (build-system haskell-build-system) |
613 | (arguments | |
614 | `(#:phases | |
615 | (modify-phases %standard-phases | |
616 | (delete 'haddock) ; Haddock fails to generate docs | |
617 | (add-after 'install 'install-udev-rules | |
618 | (lambda* (#:key outputs #:allow-other-keys) | |
619 | (let* ((out (assoc-ref outputs "out")) | |
620 | (rules (string-append out "/lib/udev/rules.d"))) | |
621 | (mkdir-p rules) | |
622 | (call-with-output-file (string-append rules "/70-kmonad.rules") | |
623 | (lambda (port) | |
624 | (display | |
625 | (string-append | |
626 | "KERNEL==\"uinput\", MODE=\"0660\", " | |
627 | "GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n") | |
628 | port))) | |
629 | #t))) | |
630 | (add-after 'install-udev-rules 'install-documentation | |
631 | (lambda* (#:key outputs #:allow-other-keys) | |
632 | (let* ((out (assoc-ref outputs "out")) | |
633 | (doc (string-append out "/share/doc/kmonad-" ,version))) | |
634 | (install-file "README.md" doc) | |
635 | (copy-recursively "doc" doc) | |
636 | (copy-recursively "example" (string-append doc "/example")) | |
637 | #t)))))) | |
638 | (inputs | |
639 | `(("ghc-cereal" ,ghc-cereal) | |
640 | ("ghc-exceptions" ,ghc-exceptions) | |
641 | ("ghc-hashable" ,ghc-hashable) | |
642 | ("ghc-lens" ,ghc-lens) | |
03b0c92e | 643 | ("ghc-megaparsec" ,ghc-megaparsec) |
51add2a9 AG |
644 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) |
645 | ("ghc-unagi-chan" ,ghc-unagi-chan) | |
646 | ("ghc-unliftio" ,ghc-unliftio) | |
647 | ("ghc-unordered-containers" ,ghc-unordered-containers))) | |
648 | (home-page "https://github.com/david-janssen/kmonad") | |
649 | (synopsis "Advanced keyboard manager") | |
650 | (description "KMonad is a keyboard remapping utility that supports | |
651 | advanced functionality, such as custom keymap layers and modifiers, macros, | |
652 | and conditional mappings that send a different keycode when tapped or held. | |
653 | By operating at a lower level than most similar tools, it supports X11, | |
654 | Wayland, and Linux console environments alike.") | |
655 | (license license:expat))) | |
656 | ||
bfccae4e LC |
657 | (define-public raincat |
658 | (package | |
659 | (name "raincat") | |
660 | (version "1.2.1") | |
661 | (source | |
662 | (origin | |
663 | (method url-fetch) | |
1e5c274e | 664 | (uri (string-append "mirror://hackage/package/Raincat/" |
bfccae4e LC |
665 | "Raincat-" version ".tar.gz")) |
666 | (sha256 | |
667 | (base32 | |
668 | "10y9zi22m6hf13c9h8zd9vg7mljpwbw0r3djb6r80bna701fdf6c")))) | |
669 | (build-system haskell-build-system) | |
670 | (arguments | |
671 | `(#:phases | |
672 | (modify-phases %standard-phases | |
673 | (add-after 'install 'wrap-executable | |
674 | (lambda* (#:key inputs outputs #:allow-other-keys) | |
675 | (let ((out (assoc-ref outputs "out"))) | |
676 | (wrap-program (string-append out "/bin/raincat") | |
677 | `("LD_LIBRARY_PATH" ":" = | |
678 | (,(string-append (assoc-ref inputs "freeglut") | |
679 | "/lib")))) | |
680 | #t)))))) | |
681 | (inputs | |
682 | `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) | |
683 | ("ghc-random" ,ghc-random) | |
684 | ("ghc-glut" ,ghc-glut) | |
685 | ("freeglut" ,freeglut) | |
686 | ("ghc-opengl" ,ghc-opengl) | |
687 | ("ghc-sdl2" ,ghc-sdl2) | |
688 | ("ghc-sdl2-image" ,ghc-sdl2-image) | |
689 | ("ghc-sdl2-mixer" ,ghc-sdl2-mixer))) | |
a15b4529 | 690 | (home-page "https://www.gamecreation.org/games/raincat") |
bfccae4e LC |
691 | (synopsis "Puzzle game with a cat in lead role") |
692 | (description "Project Raincat is a game developed by Carnegie Mellon | |
693 | students through GCS during the Fall 2008 semester. Raincat features game | |
694 | play inspired from classics Lemmings and The Incredible Machine. The project | |
695 | proved to be an excellent learning experience for the programmers. Everything | |
696 | is programmed in Haskell.") | |
697 | (license license:bsd-3))) | |
62e42dfa | 698 | |
6e241750 EF |
699 | (define-public scroll |
700 | (package | |
701 | (name "scroll") | |
702 | (version "1.20180421") | |
703 | (source | |
704 | (origin | |
705 | (method url-fetch) | |
706 | (uri (string-append | |
707 | "https://hackage.haskell.org/package/scroll/scroll-" | |
708 | version ".tar.gz")) | |
709 | (sha256 | |
710 | (base32 | |
711 | "0apzrvf99rskj4dbmn57jjxrsf19j436s8a09m950df5aws3a0wj")))) | |
712 | (build-system haskell-build-system) | |
713 | (inputs | |
714 | `(("ghc-case-insensitive" ,ghc-case-insensitive) | |
715 | ("ghc-data-default" ,ghc-data-default) | |
716 | ("ghc-ifelse" ,ghc-ifelse) | |
717 | ("ghc-monad-loops" ,ghc-monad-loops) | |
718 | ("ghc-ncurses" ,ghc-ncurses) | |
719 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
720 | ("ghc-random" ,ghc-random) | |
721 | ("ghc-vector" ,ghc-vector))) | |
722 | (home-page "https://joeyh.name/code/scroll/") | |
723 | (synopsis "scroll(6), a roguelike game") | |
724 | (description | |
725 | "You're a bookworm that's stuck on a scroll. You have to dodge between | |
726 | words and use spells to make your way down the page as the scroll is read. Go | |
727 | too slow and you'll get wound up in the scroll and crushed.") | |
728 | (license license:gpl2))) | |
729 | ||
62e42dfa RV |
730 | (define-public shellcheck |
731 | (package | |
732 | (name "shellcheck") | |
733 | (version "0.7.0") | |
734 | (source | |
735 | (origin | |
736 | (method url-fetch) | |
737 | (uri (string-append | |
738 | "https://hackage.haskell.org/package/ShellCheck/ShellCheck-" | |
739 | version ".tar.gz")) | |
740 | (sha256 | |
741 | (base32 "1vx895cp5k5h0680xfwj74lk97m9y627n965x6srds0gfnbkzy9s")) | |
742 | (file-name (string-append name "-" version ".tar.gz")))) | |
743 | (build-system haskell-build-system) | |
744 | (inputs | |
745 | `(("ghc-aeson" ,ghc-aeson) | |
746 | ("ghc-diff" ,ghc-diff) | |
747 | ("ghc-quickcheck" ,ghc-quickcheck) | |
748 | ("ghc-regex-tdfa" ,ghc-regex-tdfa))) | |
1ee45e62 | 749 | (home-page "https://www.shellcheck.net/") |
62e42dfa RV |
750 | (synopsis "Static analysis for shell scripts") |
751 | (description "@code{shellcheck} provides static analysis for | |
752 | @command{bash} and @command{sh} shell scripts. | |
753 | It gives warnings and suggestions in order to: | |
754 | ||
755 | @enumerate | |
756 | @item Point out and clarify typical beginner's syntax issues that cause | |
757 | a shell to give cryptic error messages. | |
758 | @item Point out and clarify typical intermediate level semantic problems | |
759 | that cause a shell to behave strangely and counter-intuitively. | |
760 | @item Point out subtle caveats, corner cases and pitfalls that may cause an | |
761 | advanced user's otherwise working script to fail under future circumstances. | |
762 | @end enumerate") | |
763 | (license license:gpl3+))) | |
83f9448e JS |
764 | |
765 | (define-public stylish-haskell | |
766 | (package | |
767 | (name "stylish-haskell") | |
768 | (version "0.9.2.2") | |
769 | (source | |
770 | (origin | |
771 | (method url-fetch) | |
772 | (uri | |
773 | (string-append | |
774 | "mirror://hackage/package/stylish-haskell/" | |
775 | "stylish-haskell-" version ".tar.gz")) | |
776 | (sha256 | |
777 | (base32 | |
778 | "1zs624xqp6j8vrl6pfv18dm8vz8hvz25grri65ximxhcizgwhnax")))) | |
779 | (build-system haskell-build-system) | |
780 | (inputs | |
781 | `(("ghc-aeson" ,ghc-aeson) | |
782 | ("ghc-file-embed" ,ghc-file-embed) | |
783 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
784 | ("ghc-semigroups" ,ghc-semigroups) | |
785 | ("ghc-syb" ,ghc-syb) | |
786 | ("ghc-yaml" ,ghc-yaml) | |
787 | ("ghc-strict" ,ghc-strict) | |
788 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
789 | ("ghc-hunit" ,ghc-hunit) | |
790 | ("ghc-test-framework" ,ghc-test-framework) | |
791 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) | |
792 | (home-page "https://github.com/jaspervdj/stylish-haskell") | |
793 | (synopsis "Haskell code prettifier") | |
156b08bd JS |
794 | (description "Stylish-haskell is a Haskell code prettifier. The goal is |
795 | not to format all of the code in a file, to avoid \"getting in the way\". | |
796 | However, this tool can e.g. clean up import statements and help doing various | |
797 | tasks that get tedious very quickly. It can | |
798 | @itemize | |
799 | @item | |
800 | Align and sort @code{import} statements | |
801 | @item | |
802 | Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant | |
803 | pragmas | |
804 | @item | |
805 | Remove trailing whitespaces | |
806 | @item | |
807 | Align branches in @code{case} and fields in records | |
808 | @item | |
809 | Convert line endings (customisable) | |
810 | @item | |
811 | Replace tabs by four spaces (turned off by default) | |
812 | @item | |
813 | Replace some ASCII sequences by their Unicode equivalent (turned off by | |
814 | default) | |
815 | @end itemize") | |
83f9448e | 816 | (license license:bsd-3))) |
1e19569b MB |
817 | |
818 | (define-public ghc-stylish-haskell | |
819 | (deprecated-package "ghc-stylish-haskell" stylish-haskell)) |