diff --git a/deploy.sh b/deploy.sh
index a4511a6..c0d54fc 100755
--- a/deploy.sh
+++ b/deploy.sh
@@ -2,7 +2,7 @@ rsync css/style.css ec2:~
ssh ec2 'sudo mv style.css /srv/http/hask/css/style.css'
rsync css/layout.css ec2:~
-ssh ec2 'sudo mv sidebar.css /srv/http/hask/css/layout.css'
+ssh ec2 'sudo mv layout.css /srv/http/hask/css/layout.css'
rsync js/nav.js ec2:~
ssh ec2 'sudo mv nav.js /srv/http/hask/nav.js'
diff --git a/tutorial.md b/tutorial.md
index bfef62f..d291ec6 100644
--- a/tutorial.md
+++ b/tutorial.md
@@ -1,4 +1,5 @@
% What I Wish I Knew When Learning Haskell (Version 2.3)
+-------
% Stephen Diehl
% March 2016
@@ -23,6 +24,8 @@ always accepted for changes and additional content. This is a living document.
#### Changelog
+**2.4**
+
**2.3**
* Stack
@@ -3728,6 +3731,9 @@ project is compiled without the implicit Prelude. Several packages have arisen
that supply much of the same functionality in a way that appeals to more modern
design principles.
+Protolude
+---------
+
Protolude is a minimalist Prelude which provides many sensible defaults for
writing modern Haskell and is compatible with existing code.
@@ -4063,6 +4069,13 @@ iterateUntilM :: Monad m => (a -> Bool) -> (a -> m a) -> a -> m a
whileJust :: Monad m => m (Maybe a) -> (a -> m b) -> m [b]
```
+Foundation
+----------
+
+TODO
+
+See: [Foundation](https://github.com/haskell-foundation/foundation)
+
Strings
@@ -4229,6 +4242,14 @@ See:
* [Bytestring: Bits and Pieces](https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/bytestring-bits-and-pieces)
* [ByteString](http://hackage.haskell.org/package/bytestring-0.10.4.0/docs/Data-ByteString.html)
+utf8-string
+-----------
+
+See: [utf8-string](https://hackage.haskell.org/package/utf8-string)
+
+base64-bytestring
+-----------
+
Printf
------
@@ -4682,6 +4703,11 @@ See:
+safe-exceptions
+---------------
+
+TODO
+
Advanced Monads
===============
@@ -5782,6 +5808,11 @@ See:
* [recursion-schemes](http://hackage.haskell.org/package/recursion-schemes)
+Data types à la carte
+----------------------
+
+TODO
+
Hint and Mueval
---------------
@@ -7732,6 +7763,9 @@ type instance Rep1 Maybe
:+: C1 C1_1Maybe (S1 NoSelector Par1))
```
+generics-sop
+------------
+
Uniplate
--------
@@ -8042,6 +8076,13 @@ See:
* [cvc4](http://cvc4.cs.nyu.edu/web/)
* [z3](http://z3.codeplex.com/)
+Z3
+--
+
+TODO
+
+See: [z3](https://hackage.haskell.org/package/z3)
+
Data Structures
@@ -8317,6 +8358,16 @@ x = G.insEdges edges gr
DList
-----
+Functionality Function Time Complexity
+------------------ -------- ---------------
+Initialization empty O(1)
+Size size O(1)
+Lookup lookup O(log(n))
+Insertion insert O(log(n))
+Traversal traverse O(n)
+Append (|>) O(1)
+Prepend (<|) O(1)
+
A dlist is a list-like structure that is optimized for O(1) append operations,
internally it uses a Church encoding of the list structure. It is specifically
suited for operations which are append-only and need only access it when
@@ -8335,6 +8386,8 @@ optimized for append/prepend operations and traversal.
~~~~ {.haskell include="src/20-data-structures/sequence.hs"}
~~~~
+
+
FFI
===
@@ -9146,6 +9199,43 @@ See: [Conduit Overview](https://www.fpcomplete.com/user/snoyberg/library-documen
+Cryptography
+============
+
+cryptonite
+----------
+
+entropy
+-------
+
+memory
+-------
+
+crypto-pubkey
+----------
+
+crypto-api
+----------
+
+x509
+----
+
+ed25519
+-------
+
+
+
+Compression
+============
+
+lz4
+---
+
+zlib
+----
+
+
+
Data Formats
=============
@@ -9172,6 +9262,8 @@ value ``x`` and then use ``x`` as if it were and integer throughout the rest of
your program, Aeson will select the typeclass instance which parses the given
input string into a Haskell integer.
+* [**Aeson Library**](https://hackage.haskell.org/package/aeson)
+
#### Value
Aeson uses several high performance data structures (Vector, Text, HashMap) by
@@ -9307,6 +9399,8 @@ Yaml is a textual serialization format similar to JSON. It uses an indentation
sensitive structure to encode nested maps of keys and values. The Yaml interface
for Haskell is a precise copy of ``Data.Aeson``
+* [**Yaml Library**](https://hackage.haskell.org/package/yaml)
+
~~~~ {.haskell include="src/26-data-formats/example.yaml"}
~~~~
@@ -9334,9 +9428,12 @@ Object
])
```
+To parse this file we use the following datatypes and functions:
+
~~~~ {.haskell include="src/26-data-formats/yaml.hs"}
~~~~
+Which generates:
```haskell
Invoice
@@ -9362,6 +9459,8 @@ CSV
Cassava is an efficient CSV parser library. We'll work with this tiny snippet from the iris dataset:
+* [**Cassava Library**](https://hackage.haskell.org/package/cassava)
+
~~~~ {.perl include="src/26-data-formats/iris.csv"}
~~~~
@@ -9486,6 +9585,9 @@ apply for monads may break down or fail with error terms.
See: [Making a Website with Haskell](http://adit.io/posts/2013-04-15-making-a-website-with-haskell.html)
+Servant
+-------
+
Hastache
--------
@@ -11567,6 +11669,11 @@ See:
wl-pprint-text
-------------------
+``wl-pprint-text`` is a Wadler-style pretty printing library that uses Text
+builder objects for efficient generation under the hood. It exposes effectively
+the same interface as the String-based ``pretty`` library but is much more
+performant.
+
##### Combinators
```haskell
@@ -11581,6 +11688,10 @@ See:
* [wl-pprint-text](https://hackage.haskell.org/package/wl-pprint-text)
+pretty-show
+-----------
+
+TODO
Haskeline
---------
@@ -12176,6 +12287,11 @@ throughout functional programming, and once we recognize them we can abstract
over them. For instance a monoid is a combination of a unit and a single
associative operation over a set of values.
+Structure Notation
+--------- ---------
+Monoid $(M, •)$
+Monad $(T, \mu, \eta)$
+
Categories
----------
@@ -12336,6 +12452,11 @@ transformations.
See: [You Could Have Defined Natural Transformations](http://blog.sigfpe.com/2008/05/you-could-have-defined-natural.html)
+Adjunctions
+-----------
+
+TODO
+
Yoneda Lemma
------------
@@ -12370,6 +12491,8 @@ have some a higher order polymorphic function ``g`` that when given a function
of type ``a -> b`` yields ``f b`` then the behavior ``g`` is entirely determined
by ``a -> b`` and the behavior of ``g`` can written purely in terms of ``f a``.
+**DeMorgan's Law**
+
See:
* [Reverse Engineering Machines with the Yoneda Lemma](http://blog.sigfpe.com/2006/11/yoneda-lemma.html)
@@ -12415,6 +12538,7 @@ Resources
* [Category Theory, Awodey](http://www.amazon.com/Category-Theory-Oxford-Logic-Guides/dp/0199237182)
* [Category Theory Foundations](https://www.youtube.com/watch?v=ZKmodCApZwk)
+* [Category Theory for Programmers](https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_)
* [The Catsters](http://www.youtube.com/user/TheCatsters)
@@ -12468,7 +12592,9 @@ polymorphism* through typeclasses.
Haskell is *pure* and statically tracks effects.
-Haskell employs *lazy evaluation* by default.
+Haskell employs *lazy evaluation* by default using *call-by-need*.
+
+Haskell's package manager is cabal-install or stack.
OCaml
-----
@@ -12510,6 +12636,8 @@ OCaml is not an optimizing compiler.
OCaml is *impure* by default and does not statically track effects.
+OCaml's evaluation is *call-by-value*.
+
OCaml has a package manager called [OPAM](https://opam.ocaml.org/).
Standard ML
@@ -12543,17 +12671,24 @@ Standard ML is *impure* by default and does not statically track effects.
Standard ML implementations are typically *garbage collected*.
+Standard ML's evaluation is *call-by-value*.
+
Standard ML employs strict evaluation.
Agda
----
-**Main difference**: Agda is not a general purpose language, Haskell is.
+Agda is a dependently typed functional programming language used in type theory
+research. Unlike Coq, has no support for tactics, and proofs are written in a
+functional programming style.
+
+**Main difference**: Agda is not a general purpose language, Haskell is. Agda is
+not used to write executable programs for practical uses outside of research.
Agda's main implementation is *agda*.
Agda is not a general purpose language, it is largely used as a proof
-environment.
+environment and tool for constructive mathematics.
Agda has no package manager.
@@ -12594,6 +12729,8 @@ Idris is a *general purpose language*.
Idris allows polymorphism by means of *parametric polymorphism* and *ad-hoc
polymorphism*.
+Idris's evaluation is *call-by-value*.
+
Idris is a *statically typed* language.
Idris is *garbage collected* by default, although there is some novel work on
@@ -12626,6 +12763,8 @@ Rust is a *statically typed* language.
Rust is a *general purpose language*.
+Rust's package manager is Cargo.
+
Rust allows polymorphism by means of *parametric polymorphism* and *ad-hoc
polymorphism*.
@@ -12652,6 +12791,8 @@ Purescript's main implementation is *purescript*.
Purescript is a *statically typed* language.
+Purescript's evaluation is *call-by-value*.
+
Purescript is *pure* and statically tracks effects using an extensible record
system embedded in the Eff monad.
@@ -12670,6 +12811,9 @@ Elm's main implementation is *elm*.
Elm is a *statically typed* language.
+Elm targets Javascript and is "transpiled" to Javascript source code to be run
+exclusively in a browser or Javascript interpreter.
+
Elm allows polymorphism by means of *parametric polymorphism*.
Elm is *pure* and statically tracks effects.
@@ -12700,6 +12844,13 @@ type.
R
-
+R is a programming language and software environment for statistical computing
+and graphics. The R language is widely used among statisticians and data miners
+for developing statistical software and data analysis
+
+**Main difference**: R is unityped and domain specific language, Haskell is
+statically typed and general purpose.
+
R's main implementation is *r*.
R is a *unityped* language.
@@ -12734,6 +12885,12 @@ Julia is *compiled* through the LLVM framework.
Erlang
------
+Erlang is a general-purpose programming language and runtime environment. Erlang
+has built-in support for concurrency, distribution and fault tolerance.
+
+**Main difference**: Erlang is unityped and imperative, Haskell is statically
+typed and functional.
+
Erlang's main implementation is *erl*.
Erlang is a *unityped* language.
@@ -12742,29 +12899,33 @@ Erlang is interpreted.
Erlang allows polymorphism by means of *unityping*.
+Erlang's evaluation is *call-by-value*.
+
Erlang internally refers to runtime value tags as *types*, which differs from
the Haskell notion of types.
Erlang is *impure* by default and does not statically track effects.
+Elixer
+------
Java
------
-Java is a general purpose programming language. It is an object-oriented, concurrent language
-which is statically typed. It is one of the most frequently used languages in the industry, as well
-as a common language used in academia to teach the fundamentals of object oriented programming.
+Java is a general purpose programming language. It is an object-oriented,
+concurrent language which is statically typed. It is one of the most frequently
+used languages in the industry, as well as a common language used in academia to
+teach the fundamentals of object oriented programming.
-**Main difference**: Java is an object-oriented language, compared to Haskell which is functional.
+**Main difference**: Java is an object-oriented language, compared to Haskell
+which is functional.
-Java compiles to Java Bytecode which can be ran on a Java Virtual Machine.
+Java is *statically compiled* to Java Bytecode which can be ran on a Java
+Virtual Machine.
Java's most recent version is Java8
-Java is cross-platform. It can be ran on Linux, Windows and Mac. (WORA)
-
-Java can also be used for android development
-
+Java is cross-platform. It can be ran on Linux, Windows and Mac.
Clojure
-------
@@ -12783,6 +12944,8 @@ Clojure is a *unityped* language.
Clojure allows polymorphism by means of *unityping*.
+Clojure is *garbage collected*.
+
Clojure internally refers to runtime value tags as *types*, which differs from
the Haskell notion of types.
@@ -12803,7 +12966,9 @@ Haskell is a modern functional typed language.
Swift's main implementation is *swiftc*.
Swift allows polymorphism by means of *parametric polymorphism* and *ad-hoc
-polymorphism*.
+polymorphism* through through inheritance, interfaces, and reflection.
+
+Swift is *garbage collected*.
Swift is a *statically typed* language.
@@ -12811,8 +12976,15 @@ Swift is *compiled* through the LLVM framework.
Swift *does not* have an effect system.
-C#
+Scheme
------
+
+Racket
+------
+
+C#
+--
+
C# is a typed, class-based, single-inheritance object-oriented programming
language originally developed at Microsoft as the flagship language for the
.NET framework. Early versions closely resemble *Java*, but the language has
@@ -12841,8 +13013,11 @@ C# is impure and *does not* track effects.
C# is typically *compiled* to .NET IL, which is then interpreted by the .NET
runtime.
+F#
+--
+
C++
-------
+---
C++ is a typed multi-paradigm (imperative, structured/procedural, class-based
multiple-inheritance object-oriented, template metaprogramming) programming
@@ -12904,7 +13079,33 @@ Go is *garbage collected*.
Go *does not* have an effect system.
Scala
-----------
+-----
+
+Scala is a general purpose multi-paradigm language. Like Java, Scala is
+object-oriented, and uses a curly-brace syntax reminiscent of the C programming
+language. Unlike Java, Scala has many features of functional programming
+languages like Scheme, Standard ML and Haskell, including currying, type
+inference, immutability, lazy evaluation, and pattern matching.
+
+**Main difference**: Scala mixes functional programming with imperative
+programming and does not take a language-integrated stance on purity or effect
+tracking which breaks equational reasoning. External libraries and frameworks
+exist that embrace functional programming more effectively, but it is not
+enforced and imperative code and thin wrappers around Java libs quite often
+leaks industrial codebases.
+
+Scala's main implementation is [*scala*](http://www.scala-lang.org/).
+
+Scala is a *statically typed* language.
+
+Scala allows polymorphism by means of *parametric polymorphism* and *ad-hoc
+polymorphism* through implicits.
+
+Scala is *garbage collected*.
+
+Scala language *does not* have an effect system.
+
+Scala is statically *compiled* to Java Virtual Machien bytecode.
Javascript
----------
@@ -12931,6 +13132,18 @@ from the Haskell notion of types.
The majority of Javascript implementations are garbage collected.
+Kotlin
+------
+
+PHP
+---
+
+Perl
+----
+
+Lua
+---
+
Code