Gabriella439

-- Example Annah programs and their reductions
-- I'll start with simple non-recursive data types so that you can get a feel for the syntax and then work up to recursive data
-- types followed by mutually recursive types

-- Example #1: Bool, the type
$ annah
type Bool
data True
data False
in Bool

Gabriella439

import Numeric.AD

assert = print

eval = id

main = do
    let a x = 2 * x^2 + 3
    let b = eval a 1
    assert (b == 5)         -- Prints `True`

Gabriella439

module Main where

import Data.Array ((..), reverse)
import Data.Int (toNumber)
import Flare (UI, radioGroup)
import Flare.Drawing (runFlareDrawing)
import Graphics.Drawing
import Graphics.Drawing.Font (font, sansSerif, bold)
import Math (cos, sin, pi)
import Prelude

Gabriella439

let Prelude =
      https://prelude.dhall-lang.org/package.dhall
        sha256:534e4a9e687ba74bfac71b30fc27aa269c0465087ef79bf483e876781602a454

let repeat =
        λ(t : Text)
      → λ(n : Natural)
      → Prelude.`Text`.concat (Prelude.`List`.replicate n Text t)

let spaces = repeat " "

Gabriella439

{- If I remember correctly, one consequence of Gödel's second incompleteness
   theorem is that extensional equivalence is not decidable in general for
   any programming language that can encode Peano numerals.

   The exact case that a programming language fails on may differ from language
   to language (depending on how many tricks they add to try to detect
   non-trivial equivalences).  However, many of them will typically fail to
   detect the equivalence between two ways to encode `increment` for Peano
   numerals.

Gabriella439

{- This is a bit ugly and inefficient.  See this thread for a discussion about
   adding a `Natural/subtract` built-in to improve this:

   https://github.com/dhall-lang/dhall-lang/issues/602#issuecomment-505484434
-}
let Natural/predecessor : Natural → Natural
        = λ(n : Natural)
        → let result = Natural/fold
          n
          (Optional Natural)

Gabriella439

let Prelude = https://prelude.dhall-lang.org/package.dhall

let FN = Natural/even

let a = 2

let b = 3

let c = 5

Gabriella439

{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards   #-}

import Data.ByteString (ByteString)
import Data.Default.Class (Default(..))
import GHC.Generics (Generic)
import Network.Connection (ConnectionParams(..))
import Options.Generic (ParseRecord)

Gabriella439

These are my rough notes when preparing for a Haskell livestream that I thought would be worth sharing. Some things are general comments on contributing to the open source ecosystem whereas other notes are specific to the stream (e.g. Haskell and the streamly package)

How things look from a maintainer's point of view (for highly active projects):

• Reactive

As projects become more active the maintainer's "inbox" gets pretty large. A

Gabriella439

* Importance of category theory
    * Answers the question: "What is a *timeless* API?"
        * What does "timeless" mean?
            * Likely to still be relevant years from now
            * Likely to be low maintenance (since unlikely to change)
            * Less likely to be subject to controversy or discussion ("obvious")
    * Examples:
        * Everything Haskell's typeclassopedia (except maybe `Foldable`)
        * Categories / Monoids
            * `(.)` / `id`