roboguy13

open import Relation.Binary.PropositionalEquality
open import Data.Product

open ≡-Reasoning

module MagmaMonoid where

Associative : ∀ {A} → (A → A → A) → Set
Associative _<>_ =
  ∀ a b c →

roboguy13

-- Idea:
-- (1) Define a language of normal forms:                                                       Nf
-- (2) Define translations to and from the normal form language:                                from-Nf, to-Nf
-- (3) Show that normal forms are equal if and only if they are equal in the original language: ==→~, ~→==
-- (4) Prove the theorem about normal form language:                                            thm′
-- (5) Reflect that proof back into a statement about the original language:                    thm

open import Data.Nat
open import Data.Nat.Properties
open import Relation.Binary.PropositionalEquality renaming (subst to Eq-subst)

roboguy13

open import Data.Nat
open import Data.Nat.Properties
open import Relation.Binary.PropositionalEquality
open import Data.Product
open import Data.Sum
open import Relation.Nullary

module MonoidNat3 where

data Expr : Set where

roboguy13

module NumericDSL
  where

---- Example GHCi session:
-- ghci> example (10 :: Int)
-- 130
-- ghci> example (10 :: Expr)
-- Mul (Add (Lit 10) (Lit 3)) (Lit 10)

roboguy13

{-# LANGUAGE DeriveFunctor, GADTs, UndecidableInstances #-}

module FreeExample where

import Control.Monad
import Data.Void -- Empty type

-- ghci> ppr example1
-- "Add 1 (Sub 2 3)"
example1 :: Expr Void

roboguy13

--
-- Each interpretation will have a type of the form `Expr a -> F a`.
-- These would be a natural transformations, except that Expr is not quite a functor in this case.
--

{-# LANGUAGE GADTs #-}

module ExprInterp where

data Expr a where

roboguy13

open import Data.Nat
open import Data.Sum
open import Data.Product
open import Relation.Nullary

module PreservationCounterexample
  where

data Type : Set where
  Boolean : Type

roboguy13

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE RankNTypes #-}

import Control.Lens
import Control.Applicative

data Expr
  = Lit Int
  | Add Expr Expr

roboguy13

{-# LANGUAGE GADTs #-}

import Control.Monad

-- Note that Cmd values are perfectly "pure" values. There's nothing here that
-- makes them impure.
data Cmd a where
  PutStr :: String -> Cmd ()
  PutStrLn :: String -> Cmd ()
  ReadLn :: Cmd Int

roboguy13

Inductive Tree (A : Type) :=
| tip : A -> Tree A
| bin : Tree A -> Tree A -> Tree A.

Fixpoint flatten {A} (t : Tree A) : list A :=
  match t with
  | tip _ x => x :: nil
  | bin _ l r => flatten l ++ flatten r
  end.