nonowarn

import Control.Applicative
import Control.Monad
import Data.Maybe

-- Line oriented parser
newtype Awky a = Awky { app :: String -> Maybe a }

f :: Int -> Awky String
f n = Awky $ \str -> let ws = words str; len = length ws
                     in guard (n < len) >> Just (ws !! n)

nonowarn

19:40 himabot: Applicative かわいいよ Applicative
19:49 kazu_: てすと
19:50 himabot: HIMA はじまりますよー (今回は Typeclassopedia をあがめ奉る会です)
19:59 kazu_: 始めますかー。
19:59 kazu_: こっちは、Typeclassopedia です。
20:00 himabot: HIMA はじめますよー (今回は Typeclassopedia を吊るし上げる会です)
20:00 kazu_: どう進めます？
20:00 nwn: どうしましょうか
20:00 kazu_: バラバラと質問を書いて行く？
20:01 kazu_: あるいは、論文を上から順に進んで、適宜質問を出す？

nonowarn

{-# LANGUAGE DeriveDataTypeable #-}

module Expr where

import Data.Maybe
import Data.Generics
import Control.Monad
import Control.Applicative

import Test.QuickCheck

nonowarn

nobsun: ここはHaskellプログラミングに興味をもつ人が，とりとめなく，おしゃべりをする場所です。
nobsun: またり部屋も用意してあります。> http://chaton.haskell.jp/matari/
nobsun: そろそろですね。
nobsun: 進行をどうするかちゃんと考えていませんが、「副作用」とその周辺の話題について、とりとめなくやりたいとおもいます。
nobsun: 「副作用がなくてなぜゲームが書けるのか」というところからはじめましょう。
fubabz: こんばんは
kazu: こんばんは。
nobsun: この疑問を誘発しているのは「Haskellは副作用がない」という宣伝だと思っているのですが。そうですか？
nobsun: こんばんは
kazu: そうです。

nonowarn

import System.Directory

orElse :: Maybe a -> Maybe a -> Maybe a
orElse x y = maybe y Just x

orElseM :: (Monad m) => m (Maybe a) -> m (Maybe a) -> m (Maybe a)
orElseM x y = maybe y (return . Just) =<< x

findJust :: [Maybe a] -> Maybe a
findJust = foldr orElse Nothing

nonowarn

all: anagram

anagram: anagram.hs
	ghc --make anagram.hs # -O2 -funbox-strict-fields

FILE=/usr/share/dict/words

bench: anagram
	time ruby ./anagram.rb < $(FILE)
	time ./anagram < $(FILE)

nonowarn

import Data.Monoid

type State s a = s -> (a,s)

get :: State s s
set :: s -> State s ()

get s = (s,s)
set s _ = ((),s)

nonowarn

{-# OPTIONS_GHC -fglasgow-exts #-}
{-# LANGUAGE UndecidableInstances #-}

data S a
data Z

newtype Number s = Num ()

class AsInt n where
    asInt :: Number n -> Int

nonowarn

bf: bf.hs
	ghc --make -O2 bf

nonowarn

import Data.Has
import Control.Applicative

data X = X; data Y = Y; data Z = Z

newtype Point2D = P2 (X :> Int :&: Y :> Int)
    deriving (Has (X `Labelled` Int),Has (Y `Labelled` Int))

getXY :: (Knows X Int p, Knows Y Int p) => p -> (Int,Int)
getXY = liftA2 (,) (prjl X) (prjl Y)