tags
[Programming Languages](id:9d566115-cfc1-4fec-833e-636e69a4e4fe)
Haskell is the epitome of many of the successes of strong type systems
and some of the worst programming language decisions made.
This is an [incredible breakdown of how GHC
works](https://adrian.geek.nz/haskell_docs/ghc.html). Absolutely worth
learning if you want to learn more about the language, but I'm not sure
to what degree it's worth spending time on now.
[GitHub - thma/WhyHaskellMatters: In this article I try to explain why
Haskell…](https://github.com/thma/WhyHaskellMatters) is an overview of
the language and why it matters.
# Utilities
## Hoogle
Search for programs using their type. This is the aspect of Haskell
that's most appealing: with more information encoded into the type
system - safety guarantees aside - we get far, far better program search
and reuse - because our types generally express the functionality of the
program! Being able to reuse code is incredibly nice for lots of
reasons.
hoogle plus ::
search for **combinations** of functions with hoogle! This is also at
.
# Simple Haskell
is a movement to program in only a simple, disciplined subset of the
language, in order to build a robust foundation of beginner-friendly
code that's easy to onboard programmers to without digging into the
weeds of scary monads and typeclasses. Simple Haskell preludes exist to
replace the default prelude, and the discipline usually recommends a set
of language extensions to get everyone started.
[Write Junior
Code](https://www.parsonsmatt.org/2019/12/26/write_junior_code.html): A
plea for Haskell developers to actually write code that people can
understand and hire for. [Boring Haskell
Manifesto](https://www.snoyman.com/blog/2019/11/boring-haskell-manifesto/)
also describes this, as does [Simple
Haskell](https://www.simplehaskell.org/). It's very possible that more
time has been spent pontificating about Haskell than actually writing
production code in the service… [My thoughts on Haskell in 2020 - Marco
Sampellegrini](https://marcosampellegrini.com/thoughts-on-haskell-2020).
[Haskell mini-patterns handbook ::
Kowainik](https://kowainik.github.io/posts/haskell-mini-patterns): A
book of Haskell design patterns. (I recall reading this on a particular
lunch break out of the Skira office; the ideas sunk in at the time and
could be applied to our class PL code. We should have used it).
There are many resources written with this practice in mind.
- [Real World Haskell](http://book.realworldhaskell.org/)
- [The golden rule of software quality :
haskell](https://www.reddit.com/r/haskell/comments/hz4sec/the_golden_rule_of_software_quality/)
- [GitHub - graninas/software-design-in-haskell: Software Design in
Haskell. A s…](https://github.com/graninas/software-design-in-haskell)
- [Appendix to Software Design in Haskell ·
GitHub](https://gist.github.com/graninas/ef5dd5a2b57903af81039fb21ff3b0bf)
- [Type Classes](https://typeclasses.com/): start learning haskell with
good documentation, various inline demonstrations, and a book.
- [haskell competency
matrix](https://gist.github.com/graninas/833a9ff306338aefec7e543100c16ea1):
to identify where you're at with respect to your Haskell knowledge and
figure out what you have left to learn.
- [adventures in uncertainty: Towards Faster Iteration in Industrial
Haskell](https://blog.sumtypeofway.com/posts/fast-iteration-with-haskell.html)
# GHC
[How Accursed and Unutterable is
accursedUnutterablePerformIO?](https://free.cofree.io/2020/07/20/perform-io/)
[Creating GHC Rewrite
rules](https://downloads.haskell.org/~ghc/7.0.1/docs/html/users_guide/rewrite-rules.html)
[Runtime Support for Multicore Haskell: a Retrospective \| SIGPLAN
Blog](https://blog.sigplan.org/2019/12/16/runtime-support-for-multicore-haskell-a-retrospective/):
On multicore Haskell. One of the biggest benefits of pure functional
programming is parallel computation, so this better work well. [Type
Technology Tree : ezyang’s
blog](http://blog.ezyang.com/2011/03/type-tech-tree/): How to consider
different Haskell language extensions. What do they mean? How can they
be applied? How do we determine when to use them?
[GHC.Generics](https://hackage.haskell.org/package/base-4.12.0.0/docs/GHC-Generics.html):
Datatype-generic functions that programmers can use and reuse,
parameterizing them.
## TemplateHaskell
backlinks
[Macros](id:7468d7ac-2421-4cc5-93f4-5e3f02c1709b)
[An excellent Template Haskell
Tutorial](https://markkarpov.com/tutorial/th.html), and another:
# Interesting
[GitHub - tathougies/hos: The functional Haskell
kernel](https://github.com/tathougies/hos): a kernel for a Haskell
operating system. (What?) [Paweł Szulc - Maintainable Software
Architecture in Haskell (with Polysemy)
-…](https://www.youtube.com/watch?app=desktop&feature=youtu.be&v=kIwd1D9m1gE)
[Hasktorch: A Comprehensive Haskell Library for Differentiable
Functional Prog…](https://www.youtube.com/watch?v=SjxP1NpoP2c)
[Implementing Linear Haskell -
YouTube](https://www.youtube.com/watch?v=uxv62QQajx8) [Lambda calculus
on the type level with GHC 7.11.20151212. ·
GitHub](https://gist.github.com/AndrasKovacs/c7d385aa117929503feb)
# Categories
[Comonads \| Bartosz Milewski's Programming
Cafe](https://bartoszmilewski.com/2017/01/02/comonads/) [Category
theory](id:8ee564b3-afbb-4d5b-b971-5ae4cb7f47ef)
[Math](id:ea48654b-309e-4b25-b322-c0957adfc218) [Haskell and Category
Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory) [Category
theory](id:8ee564b3-afbb-4d5b-b971-5ae4cb7f47ef) [Category Theory \|
Haskell Language
Tutorial](https://haskell.programmingpedia.net/en/tutorial/2261/category-theory)
# Getting Started
## Setting Up Stack
``` bash
wget https://get.haskellstack.org/stable/linux-x86_64-static.tar.gz
rm -rf linux-x86_64-static.tar.gz
export PATH=$PATH:./s
```
### Creating a project
creating project:
``` bash
stack new Other simple
stack setup
getting ncurses5-compat-libs:
```
# Proofs in Haskell?
- [A casual guide to proving things in
Haskell](https://blog.madsbuch.com/proving-stuff-in-haskell/)
- [Dependent types in the context of Haskell (limited
support)](https://wiki.haskell.org/Dependent_type)
- :
Expression of orderings with haskell dependent types, via
liquidhaskell.
- [A more rigorous overview of dependently typed programming in
Haskell](https://jeltsch.wordpress.com/2012/04/30/dependently-typed-programming-and-theorem-proving-in-haskell/)
- [Towards Tactic Metaprogramming in Haskell :: Reasonably
Polymorphic](https://reasonablypolymorphic.com/blog/towards-tactics/index.html)
# things to remake in haskell (and maybe racket!)
:: make
[music](id:a2d0ed7c-5b6e-41b4-a6b9-4072075e66ff) with haskell from
scratch
# etc
[GitHub - davdar/parsing-with-derivatives-haskell: The original parsing
with d…](https://github.com/davdar/parsing-with-derivatives-haskell):
Parsing with derivatives, as the parser maps to one! Very cool idea.
[Haskell for all: Introductions to advanced Haskell
topics](https://www.haskellforall.com/2014/03/introductions-to-advanced-haskell-topics.html?m=1)
[Locally Nameless](https://boarders.github.io/posts/locally-nameless/)
[djinn: Generate Haskell code from a
type](https://hackage.haskell.org/package/djinn)! With an associated
blog post: [Let’s play a game : ezyang’s
blog](http://blog.ezyang.com/2011/09/lets-play-a-game/). [Conal Elliott
» Blog Archive » “Everything is a function” in
Haskell?](http://conal.net/blog/posts/everything-is-a-function-in-haskell)
[linear](https://das.li/articles/linear.html) algebra library
implemented and experimented with in Haskell. [accelerate: An embedded
language for accelerated array
processing](https://hackage.haskell.org/package/accelerate):