Topics in Haskell beyond LYAH

[jhhuh]

Topics in Haskell beyond LYAH

Type theory related

1. Functor-Applicative-Monad typeclass hierarchy (covered in LYAH)

2. State monad (covered in LYAH)

3. GeneralZipper as a derivative to ADT (covered in LYAH)

4. Monad Stack (mtl library)

5. Monadic Parser (attoparsec library, parsec library)

6. JSON parser (aeson library)

   • https://web.archive.org/web/20201121162141mp_/https://artyom.me/aeson

   1. General Applicative programming (generalization to zipWith etc)

   2. Original paper: https://dl.acm.org/doi/10.1017/S0956796807006326

   3. Foldable and Traversable typeclasses

   4. Arrow and Category typeclasses

   5. Generalized Algebraic Data Types (GADT)

   6. Type family / data family

   7. Existential quantification (Important)

      • https://blog.sumtypeofway.com/posts/existential-haskell.html
      • https://markkarpov.com/post/existential-quantification.html

7. Type application

8. () type, Void type, undefined vs absurd (relation to the Category Hask)

GHC runtime related

1. Strictness annotation, and seq vs deepseq

2. Parallelism and par-monad

3. (Un-)/boxed types and Thunks

   • https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.50.231&rep=rep1&type=pdf
     • (It is the paper on which the current GHC implementation is based.)

4. Stream (Pipes, Conduit, and Streamly libraries) and Iteratee (Very important for our use case)

5. Vector library

6. Foreign Function Interface (FFI)

7. Resource handling and Exceptions

   • https://www.fpcomplete.com/haskell/tutorial/exceptions/
   • https://markkarpov.com/tutorial/exceptions.html
   • (This tutorial is quite good, as far as I remember.)

8. Mutable states and strict state threads (IORef, ST monad, STRef)

On how to program in Haskell

1. Lens library, Profunctor, and general optics (relation to Yoneda lemma?)

2. Template Haskell and Quasi Quotation

3. ReaderT pattern + Capability constraints (and RIO library)

   • https://www.fpcomplete.com/blog/2017/06/readert-design-pattern/
   • https://www.tweag.io/blog/2018-10-04-capability/
   • https://www.fpcomplete.com/haskell/library/rio/

4. Concurrency primitives (forkIO, MVar, etc)

5. Software Transaction Memory (STM) and async library (atomically, TVar, async, Concurrently, etc) (Important for our use case)

6. DataKinds and phantom types + basic type-level programming (case study in servant and safe-money libraries)

   • https://haskell-servant.github.io/posts/2018-07-12-servant-dsl-typelevel.html
   • https://ren.zone/articles/safe-money

7. Typeclass metaprogramming

   • Alexis King's blog post: https://lexi-lambda.github.io/blog/2021/03/25/an-introduction-to-typeclass-metaprogramming/

8. Reflection and type witness and proof

9. singletons library, and dependent types

   • Richard Eisenberg's Thesis: https://www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf
   • https://blog.jle.im/entry/introduction-to-singletons-1.html
   • https://blog.jle.im/entry/introduction-to-singletons-2.html
   • https://blog.jle.im/entry/introduction-to-singletons-3.html
   • https://blog.jle.im/entry/introduction-to-singletons-4.html
   • Dependent Haskell: https://serokell.io/blog/how-dependent-haskell-can-improve-industry-projects

10. Recursion Schemes (and F-algebra)

    • Original paper: https://maartenfokkinga.github.io/utwente/mmf91m.pdf
    • https://blog.sumtypeofway.com/posts/introduction-to-recursion-schemes.html
    • https://blog.sumtypeofway.com/posts/recursion-schemes-part-2.html
    • https://blog.sumtypeofway.com/posts/recursion-schemes-part-3.html
    • https://blog.sumtypeofway.com/posts/recursion-schemes-part-4.html
    • https://blog.sumtypeofway.com/posts/recursion-schemes-part-4-point-5.html
    • https://blog.sumtypeofway.com/posts/recursion-schemes-part-5.html

11. Beyond monad stack and Interpreter pattern (Algebraic Effects systems and Free Monad)

    • https://haskell-explained.gitlab.io/blog/posts/2019/07/28/polysemy-is-cool-part-1/
    • https://haskell-explained.gitlab.io/blog/posts/2019/07/31/polysemy-is-cool-part-2/
    • https://serokell.io/blog/introduction-to-free-monads
    • https://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html

[jhhuh]

@lsg6140 @sepiabrown @jjdosa @kwkim00

Why don't we have a few special guest sessions once those FP kata sessions are done? Like..

1. Typeclass metaprogramming + singletons library, and dependent types (@kwkim00)
2. Recursion Schemes (and F-algebra) (@jjdosa)
3. Beyond monad stack and Interpreter pattern (Algebraic Effects systems and Free Monad) (@jhhuh)

As for each topic being a complete concise single so that both the taker and giver get benefit from, hopefully.

I know we are quite busy for many things. It is just an idea for the time when we have a time.

[kwkim00]

@jhhuh @lsg6140 @sepiabrown @jjdosa

I like this! :+1:

if we all agree with this, why don't we start the first session after submitting the Jun Report?

[lsg6140]

I love this suggestion!!!

But, it is difficult to estimate when the FP kata will be done. :joy:

[jjdosa]

I believe that adding Scrap Your Boilerplate to the list would be beneficial. However, I am concerned that too much emphasis is being placed on high-level aspects of Haskell for Kata practitioners. It may be more effective to include implementation practices that utilize the skills learned thus far, allowing Kata practitioners to become comfortable with implementing functional code that they could write with ease in a language they are more familiar with, even if the implementation is untidy or disorganized.

My suggestion is to organize a term project period for Kata practitioners to develop a program of moderate size that is neither too small with only a few snippets of code nor too large like a full-fledged application. Once the program is completed, it can be reviewed to identify areas that could benefit from advanced programming techniques, such as typeclass metaprogramming, dependent types, F-algebra, free monad, and so on. This approach provides concrete motivation for advanced programming techniques, as practitioners can see how they can be applied in real programming scenarios. During the refactoring process, advanced theoretical concepts can be incorporated through theory sessions that will solidify the practitioner's understanding of the concepts.