m-renaud

{-# LANGUAGE TemplateHaskell #-}
module MatrixDemo where

import Control.Lens

-- | Represents a matrix with the contents stored in row major order.
--   Note that we get equality, ability to read a Matrix from a stream
--   as well as write it to a stream for free by deriving (Eq,Read,Show).
data Matrix = Matrix { _numRows        :: Int
                     , _numColumns     :: Int

m-renaud

#include <iostream>
#include <vector>

using std::vector;

// Represents a matrix with the contents stored in row major order.
struct Matrix {
	int numRows;
	int numColumns;
	vector<vector<int>> contents;

m-renaud

f :: [[a]] -> Bool
f matrix = flattenedMatrix == (reverse flattenedMatrix)
    where flattenedMatrix = concat matrix

-- Note that concat (defined in the default environment) simply flattens a list of lists into a list.
concat :: [[a]] -> [a]

m-renaud

-- This version runs in ~0.7 seconds due to String actually being a linked list 
-- of Char. Not super efficient.
main = do
  chars <- head <$> getArgs
  englishWords <- words <$> readFile "en.txt"
  mapM_ putStrLn $ sortBy (comparing length) $ findValidWords chars englishWords

findValidWords :: String -> [String] -> [String]
findValidWords chars englishWords = filter (`canBeMadeWith` chars) englishWords

m-renaud

-- | Timing breakdown:
--     Reading: 2.5s
--     Sorting: 3.5s

module Main where

import Control.Applicative
import Control.Monad
import Data.ByteString.Char8 (pack)
import Data.Attoparsec.ByteString.Char8

m-renaud

{-# LANGUAGE BangPatterns #-}
module FastParse (parseInts) where

import Prelude hiding (length)

import Control.Applicative hiding (empty)
import Control.Monad
import Data.Char
import Data.Maybe
import Data.Sequence

m-renaud

{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -Odph #-}

import qualified Data.ByteString.Char8      as S
import qualified Data.Vector                as U

-- Read ints from stdin into a vector then print the length.
main = S.getContents >>= print . U.length . parse

-- Fill a new vector from a file containing a list of numbers.

m-renaud

{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -Odph #-}

import Prelude hiding (map, sum)
import qualified Data.ByteString.Char8 as S
import Data.List.Stream

main = S.getContents >>= print . sumOfSquares . parse
  where sumOfSquares = sum . map (\x -> x * x)

m-renaud

module ParseUriQuery where

import Control.Applicative
import Data.Attoparsec.ByteString.Char8
import Data.ByteString.Char8 (ByteString, pack, unpack)
import Data.Either

data QueryTerm = QueryTerm { termName  :: ByteString
                           , termValue :: Maybe ByteString
                           } deriving (Eq, Read, Show)

m-renaud

set bind-tty-special-chars off

Control-h: backward-char
"\eh": backward-word

Control-t: previous-history
Control-n: next-history

Control-s: forward-char
"\es": forward-word