gelisam

{-# OPTIONS --type-in-type #-}
module Main where

open import Data.Empty


data _≡_ (A : Set) : Set → Set where
  refl : A ≡ A

subst : {P : Set → Set} → {x y : Set} → x ≡ y → P y → P x

gelisam

import Debug.Trace


noisy0 :: () -> Int
noisy0 () = trace "eval" 0

main = do print (let x = ( noisy0 ()
                         , fst x)
                  in x)                -- evals noisyMempty once
          print (( noisy0 ()

gelisam

Hawk

Transform text from the command-line using Haskell expressions. Similar to awk, but using Haskell as the text-processing language.

Examples

The Haskell expression (!! 1) takes the second element from a list. Using Hawk to --map this expression over all input lines, we can extract the second column of the output of ps aux.

gelisam

{-# LANGUAGE FlexibleInstances, OverloadedStrings #-}
import Prelude
import qualified Data.ByteString.Lazy.Char8 as B
import qualified Data.List as L
import Data.Monoid
import Data.Tree hiding (Forest)
import System.Console.Hawk.Representable


newtype Forest a = Forest {unForest :: [Tree a]}

gelisam

{-# LANGUAGE NullaryTypeClasses, Rank2Types #-}
import Prelude hiding (log)
import Unsafe.Coerce
import System.IO.Unsafe


class NeedsInit

provideInit :: (NeedsInit => a) -> (() -> a)
provideInit = unsafeCoerce

gelisam

-- in reply to http://www.reddit.com/r/haskell/comments/1zf3ay/trying_to_design_a_gui_library/

{-# LANGUAGE ExistentialQuantification #-}

import Text.Printf


type Key = String

data Widget s = Widget

gelisam

-- In response to [1].
-- 
-- I am aiming for readability, not conciseness. Nevertheless, a note
-- explaining why the original javascript code is so much shorter:
-- Javascript skips all error checking unless you perform explicit checks.
-- Haskell enforces all error checking unless you explicitly ignore errors.
-- I have thus implemented many wrapping functions whose purpose is to use
-- incomplete pattern-matching to ignore errors.
-- 
-- I am using the aeson package for JSON and the download-curl package for

gelisam

{-# LANGUAGE GADTs, StandaloneDeriving, TypeFamilies, MultiParamTypeClasses #-}
module Main where

import Data.Word


type family Promote a b where
  Promote Word8  Word16 = Word16
  Promote Word16 Word8  = Word16
  Promote a a = a

gelisam

-- A small imperative language with a single anonymous mutable variable.
-- In response to http://www.reddit.com/r/haskell/comments/207mcn/binding_type_variables_using_the_bound_library/
{-# LANGUAGE DeriveFunctor #-}
module Main where

import Control.Monad.Trans.Class
import Control.Monad.Trans.State
import Bound

gelisam

-- in reply to http://www.reddit.com/r/haskell/comments/21mja6/make_lllegal_state_transitions_unrepresentable/
-- 
-- We implement a tiny language with three commands: Open, Close, and Get.
-- The first Get after an Open returns 1, the second Get returns 2, and so on.
-- 
-- Get is only valid while the state is open, and
-- Open must always be matched by a Close.
-- We enforce both restrictions via the type system.
-- 
-- There are two valid states: Opened and Closed.