View s_k_lt_k_proof.idr
module Main
%hide (>)
data (>) : (a : Nat) -> (b : Nat) -> Type where
ZeroCase : 1 + a > 0
OtherCase : a > b -> 1 + a > 1 + b
s_k_lt_k_proof : {k : Nat} -> 1 + k > k
s_k_lt_k_proof {k=Z} = ZeroCase
View pfsmfv.md
  • Make state immutable (in PS everything is immutable so 0 overhead for this)
  • No getters, no mutations: Lens, or something similar, may work here
    • get :: forall state a. (state -> a) -> ActionT state () a
    • commit :: forall state. (state -> state) -> ActionT state () Unit
  • actions :: forall state eff. ActionT state (Aff eff) Unit?
data AppState = AppState { counter :: Int }

type Action eff = ActionT AppState (Aff eff) Unit
View rl.md
View TraceExample.purs
module Main where
import Prelude
import Control.Monad.Eff.Console (log)
import Debug.Trace (trace)
f :: Int -> String
f 1 = "one"
f 2 = "two"
f _ = "meh"
View emacs-24.5-24bit.diff
This is a modified version of the patch found here:
https://gist.github.com/choppsv1/36aacdd696d505566088
Which itself is a modified version of:
http://emacs.1067599.n5.nabble.com/RFC-Add-tty-True-Color-support-tt299962.html
To use true-color, use the flag --color=true-color.
Alternatively, set the EMACS_TRUE_COLOR_SEPARATOR environment variable to
either ':' or ';'.
View Main.hs
module Main where
import Control.Applicative
import Data.Monoid
import Test.QuickCheck
import Test.QuickCheck.Checkers
import Test.QuickCheck.Classes
instance Monoid a => Monoid (ZipList a) where
mempty = pure mempty
View Main.hs
module Main where
import Control.Applicative
import Data.Monoid
import Test.QuickCheck
import Test.QuickCheck.Checkers
import Test.QuickCheck.Classes
instance Monoid a => Monoid (ZipList a) where
mempty = pure mempty
View Main.hs
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeOperators #-}
module Main where
-- | 'f ~> g' means natural transformation from a functor 'f' to a functor 'g'
type (~>) f g = forall a. f a -> g a
-- | const functor, which works as if it's just a constant
View Spec.hs
import Test.Hspec
import Test.Hspec.QuickCheck (prop)
main :: IO ()
main = hspec $ do
describe "quickcheck" $ do
prop "assoc" $ \x y z ->
x + (y + z) == ((x + y) + (z :: Double))
View sum-of-records-bottom-haskell.md

Let me guess there is a data PL as a sum type of records:

data PL = Functional { name :: String, pure :: Bool }
        | ObjectOriented { name :: String, multipleInheritance :: Bool }

The type of pure is: