Is Haskell an acceptable Perl?

Is Haskell an Acceptable Perl?

@osfameron

LambdaLounge MadLab 18 April 2016

https://github.com/osfameron/haskell-perl

Overview

Perl:

https://www.perl.org/

Perl 5 is a highly capable, feature-rich programming language with over 27 years of development

Haskell:

https://www.haskell.org/

An advanced purely-functional programming language

An open source community effort for over 20 years

Received Wisdom?

Perl:

dynamic

messy

simple

flexible

Haskell:

static

clean

hard

mathsy

Received Wisdom?

Perl:

dynamic

messy

simple

flexible

$?=~s/(?:[%^]+)/a/gsmx;

Haskell:

static

clean

hard

mathsy

a>>=(c@(_ _)->b’$c:[d])

Comparison

Perl:

Imperative

OO

Functional

“Weakly typed”

Real World

Haskell:

- (or best?)

-

Purely Functional

Strongly typed

?

Comparison

Perl:

Imperative

OO

Functional

“Weakly typed”

Real World

“whipuptitude”

Haskell:

- (or best?)

-

Purely Functional

Strongly typed

?

“manipulexity”

“Around 1993 I started reading books about Lisp, and I discovered something important:

Perl is much more like Lisp than it is like C.”

What Makes Lisp Different?

“…describes seven features of Lisp.

Perl shares six of these features; C shares none of them.

These are big, important features, features like first-class functions, dynamic access to the symbol table, and automatic storage management.”

-- mjd

Perl6:

1st implementation (Pugs) written in Haskell!

Many Haskell ideas influenced design of Perl6.

GHC:

Used Perl to prototype early versions of key components

(the Evil Mangler, etc.)

still required for “boot” script to build ghc from source

Example:

??? (“Annie”, “Bob”, “Chandra”)

=> (5, 3, 7)

Example:

map ??? (“Annie”, “Bob”, “Chandra”)

=> (5, 3, 7)

Example:

map length, (“Annie”, “Bob”, “Chandra”)

=> (5, 3, 7)

Perl vs Haskell?

??? map length,

(“Annie”, “Bob”, “Chandra”)

Map

map length,


map length

[“Annie”, “Bob”, “Chandra”]

Map

map length,


map length


length :: String -> Int

length “Annie” => 5

map length :: [String]->[Int]

map :: (a -> b) -> [a] -> [b]

Map

map length,


# map EXPR, LIST

# map BLOCK LIST

map { length } (…)

map length


Map

map length,


# map EXPR, LIST

# map BLOCK LIST


map length


Map

map length,


# map EXPR, LIST

# map BLOCK LIST


# length EXPR

# length

# If EXPR is omitted, returns the length of $_

map length


Map

map length,


• expression

• $_ (“it”)

• optional parameters

map length


• function

• currying

• “lifting”

Doubling

map $_ * 2, (1..5)

=> (2,4,6,8,10)

map (*2) [1..5]

=> [2,4,6,8,10]

Doubling

map double($_), (1..5)

use experimental ‘signatures’;

sub double ($x) { $x * 2 }

map double [1..5]

double x = x * 2

-- or

double = (*2)

Define our own ‘fmap’

fmap \&double, (1..5)


sub fmap ???

map double [1..5]

double x = x * 2

-- or

double = (*2)

Define our own ‘fmap’

fmap \&double, (1..5)


sub fmap ($fn, @list) {

map $fn->($_), @list

}

map double [1..5]

double x = x * 2

-- or

double = (*2)

Prototypes...

map _\&double, (1..5)


{

no experimental 'signatures';

sub _ ($) { shift->($_) }

}

map double [1..5]

double x = x * 2

-- or

double = (*2)

Reverse...

??? map reverse

[“foo”, “bar”]

=> [“oof”, “rab”

Reverse...

map reverse,

(“foo”, “bar”)

=> ...

map reverse


=> [“oof”, “rab”

Reverse...

map reverse,


=> () # wtf?

map reverse


=> [“oof”, “rab”

Reverse...

map reverse,


=> ()

# reverse LIST

reverse (“foo”, “bar”)

=> (“bar”, “foo”)

reverse () => ()

# reverse STRING

reverse “foo” => “oof”

# reverse ($_)

map reverse


=> [“oof”, “rab”

Reverse...

map scalar reverse,


=> (“oof”, “rab”)

map reverse


=> [“oof”, “rab”

Reverse...

map scalar reverse,


=> (“oof”, “rab”)

• map is really concatMap!

map reverse


=> [“oof”, “rab”

concatMap vs map

map {$_,$_} (1..3)

=> (1,1,2,2,3,3)

map (\x->[x,x]) [1..3]

=> [[1,1],[2,2],[3,3]]

concatMap vs map

map {$_,$_} (1..3)

=> (1,1,2,2,3,3)

concatMap (\x->[x,x]) [1..3]

=> [1,1,2,2,3,3]

Reverse with concatMap

map scalar reverse,


=> (“oof”, “rab”)

concatMap reverse


=> [“oofrab”] -- eeek!

Reverse with concatMap

map scalar reverse,


=> (“oof”, “rab”)

• scalar vs list context

concatMap (return . reverse)


=> [“oof”, “rab”]

• map vs concatMap

• return (to wrap value in e.g. list)

Length of lists of lists:

??? ([1,2,3], [5,4,3,2,1])

=> (3, 5)

Length of LoL

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]

length :: [a] -> Int

Length of LoL

my @l = ([1,2,3], [5,4,3,2,1]);

map length, @l

=> (16, 16) # wtf

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]


Length of LoL

my @l = ([1,2,3], [5,4,3,2,1]);

map length, @l

=> (16, 16)

# length STRING

[1,2,3] => “ARRAY(0x293a1d8)”

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]


Length of LoL

my @l = ([1,2,3], [5,4,3,2,1]);

map length, @l

=> (16, 16)

# length STRING

[1,2,3] => “ARRAY(0x293a1d8)”

# scalar @array

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]


Length of LoL

my @l = ([1,2,3], [5,4,3,2,1]);

map scalar, @l

=> ([1,2,3], [5,4,3,2,1])

# [1,2,3] is already scalar!

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]


Length of LoL

my @l = ([1,2,3], [5,4,3,2,1]);

map scalar @$_, @l

=> (3, 5)

l = [[1,2,3], [5,4,3,2,1]]

map length l

=> [3, 5]


Tails

??? map tail l

=> [[2,3], [4,3,2,1]]

Tails

map [ @$_[1..$#$_] ], @l

=> ([2,3], [4,3,2,1])

map tail l

=> [[2,3], [4,3,2,1]]

Tails

map [ @$_[1..$#$_] ], @l

=> ([2,3], [4,3,2,1])

• Yes, I know

map tail l

=> [[2,3], [4,3,2,1]]

Tails

map tail($_), @l

=> () # bah!

sub tail ($head, @tail) {

@tail

}

map tail l

=> [[2,3], [4,3,2,1]]

Tails

map __\&tail, @l

=> ([2,3], [4,3,2,1])

sub tail ($head, @tail) {

@tail

}

{

no experimental 'signatures';

sub _ ($) { shift->($_) }

sub __ ($) { [shift->(@$_)] }

}

map tail l

=> [[2,3], [4,3,2,1]]

A thought...

Scalar/list context

Sigils ($, @, %)

implicit $_

Optional parameters

References and dereferencing

Automatic type coercions

Subroutine prototypes

Type system

Example

Scalar/list context Monads (Maybe, List)

Example:

-- https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail

import qualified Data.Map as M

en2it = M.fromList [

("hello","ciao"),

("goodbye","ciao"),

("pasta","pasta") ]

translate db k =

let v = M.lookup k db

in case v of

Nothing -> fail "No translation"

Just v' -> return v'

https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail

Example:

*Main> translate en2it "hello"

"ciao"

*Main> translate en2it "hello" :: Maybe String

Just "ciao"

*Main> translate en2it "hello" :: [String]

["ciao"]

*Main> translate en2it "whipuptitude"

*** Exception: user error (No translation)

*Main> translate en2it "whipuptitude" :: Maybe String

Nothing

*Main> translate en2it "whipuptitude" :: [String]

[]

To be fair...

Perl:

• Larry Wall: linguist, missionary

• + jobbing programmers

• pragmatic

• magpie-like

Haskell:

• Decades of Comp Sci professors and PhD students

• purity

• experimentation

Why are we* so terrified of types?

en2it :: M.Map [Char] [Char]


("hello","ciao"),

("goodbye","ciao"),

("pasta","pasta") ]

translate :: (Monad m, Ord k) => M.Map k a -> k -> m a

translate db k =


in case v of




en2it :: M.Map [Char] [Char]


("hello","ciao"),

("goodbye","ciao"),

("pasta","pasta") ]

translate :: (Monad m, Ord k) => M.Map k a -> k -> m a

translate db k =


in case v of




“Programming in ML is very pleasant. More than almost any other language I know, you can just write down the definitions of the functions as they come into your head. You don't need to bother with declarations; everything is just figured out for you automatically.

And you do get a lot of type errors, both actual failures and also places where the type emitted by the compiler is not what you thought it should be.

But unlike in C or Pascal, every one of those errors indicates a real, serious problem in your program, not merely something you have to groan over and try to work around the compiler's stupidity yet again.”

-- mjd http://perl.plover.com/classes/typing/notes.html

http://perl.plover.com/classes/typing/notes.html


[4, 8, 15, 16, 23, 42] :: [Int]

Type terror: undefined values

[4, 8, 15, undef, 16, 23, 42] :: [Panic!]


my %en2it = (

hello => “ciao”,

goodbye => “ciao”,

pasta => “pasta”

);

my @l = map $en2it{$_},

(“hello", “monad", “pasta”);

my @c = grep defined, @l;

# (“ciao”, “pasta”)


-- data Maybe a = Just a | Nothing

l = map (flip Map.lookup h)

[“hello", “monad", “pasta”]

-- [Just “ciao”, Nothing, Just “pasta”]

c = catMaybes l

-- [“ciao”, “pasta”]

Type terror: signal values

[1, undef, 2, “X”, 3, -5]

# positive number: record

# undef: no record found

# “string”: processing instruction

# negative number: record flagged for deletion

Type terror: signal values

records :: [Maybe Record]

records = [

Just Record (Left 1),

Nothing,


Just Instruction “X”


Just Record (Right 5)]

data Record =

Record (Either Int Int) | Instruction String

Type terror: but! but! but!

serialization (show)

objects of a particular class (typeclasses)

GADTs

existential types

dynamic introspection

...

Bonus section #1practical oneliners

april.txt

There is shadow under this red rock,

(Come in under the shadow of this red rock),

And I will show you something different from either

Your shadow at morning striding behind you

Or your shadow at evening rising to meet you;

I will show you fear in a handful of dust.

Grep for a string

$ perl -ne ‘print if /shadow/’ < april.txt

???

Grep for a string


notaoneliner.hs:

import Data.List

main = interact (

unlines .

(filter (\a -> "shadow" `isInfixOf` a))

. lines )

$ runghc notaoneliner.hs < april.txt

april.txt | grep shadow





Grep for a string


hask.bash:

if which ghc > /dev/null

then

function h { ghc -e "interact ($*)" Ust.hs ; }

function hl { h "bylines ($*)" ; }

function hw { h "bywords ($*)" ; }

fi

$ hl ‘filter (regexBool “shadow”)’ < april.txt

Ust.hs

https://wiki.haskell.org/Simple_Unix_tools

https://ulissesaraujo.wordpress.com/tag/command/

{-# LANGUAGE NoMonomorphismRestriction #-}

module Ust(

bylines, bywords, showln, regexBool, uniq, rpt, take', drop', head', tail', tail10, tac, rev, rev_w, wc_c, wc_l, wc_w, space, unspace, remove, upper, clean, clean', clean'', blank, join, tr, tr_d, grep, grep_v, cksum

) where

import Control.Monad.Instances; import Data.List; import Data.Char; import Data.Maybe; import Text.Printf; import System.Environment; import Text.Regex.Posix

-- First, three helpers

bylines f = (unlines . f . lines)

bywords f = (unwords . f . words)

showln = (++ "\n") . show

-- simple boolean regex matching

regexBool r l = l =~ r :: Bool

...

https://wiki.haskell.org/Simple_Unix_tools

https://ulissesaraujo.wordpress.com/tag/command/

Uppercase

$ perl -pe ‘$_ = uc’ < april.txt

$ h upper < april.txt

Ust.hs:

upper = map toUpper

april.txt | upper

THERE IS SHADOW UNDER THIS RED ROCK,

(COME IN UNDER THE SHADOW OF THIS RED ROCK),

AND I WILL SHOW YOU SOMETHING DIFFERENT FROM EITHER

YOUR SHADOW AT MORNING STRIDING BEHIND YOU

OR YOUR SHADOW AT EVENING RISING TO MEET YOU;

I WILL SHOW YOU FEAR IN A HANDFUL OF DUST.

Sort

$ perl -e 'print sort <>' < april.txt

$ hl sort < april.txt

april.txt | sort


And I will show you something different from either

I will show you fear in a handful of dust.




Sorted words

$ perl -e 'print join " ",

sort map { chomp; split } <>' < april.txt

$ hw sort < april.txt

april.txt | sort-words

(Come And I I Or There Your a at at behind different dust. either evening fear from handful in in is meet morning of of red red rising rock), rock, shadow shadow shadow shadow show show something striding the this this to under under will will you you you you; your

Bonus section #2real world(ish) code

Modelling TV programmes

Brand:“Have I Got News For You?”

Series:“3”

Episode:“1” /

HIGNFY123

Modelling TV programmes

Brand:“Have I Got News For You?”

Series:“3”

Episode:“1” /

HIGNFY123

Brand:“Have I Got OLD News For You?”

Series:“1”

Episode:“5” /

HIGNFY123

Data modelling

package Programme;

use Moo;

use Types::Standard

qw/ Maybe Str /;

has id => ( is => 'ro',

isa => Maybe[Str] );

has id2 => ( is => 'ro',

isa => Maybe[Str] );

package Brand;

use Moo;

extends 'Programme';

# ditto Series, Episode...

type PrimaryId = Maybe String

type AlternateId = Maybe String

data Prog = Prog

ProgType

PrimaryId AlternateId

deriving (Eq, Ord, Show)

data ProgType =

Brand |

Series |

Episode

deriving (Eq, Ord, Show)

The “Database”package Database;

use Moo;

use Types::Standard

qw/ArrayRef HashRef InstanceOf/;

has list => (

is => 'ro',

isa => ArrayRef[InstanceOf["Programme"]],

...

);

has graph => (

is => 'ro',

isa => HashRef[InstanceOf["Programme"]],

...

);

data Database = Database {

list :: [Prog],

graph :: M.Map Prog Prog

}

Get Hierarchyuse experimental ‘signatures’;

sub getHierarchy($self, $prog) {

if (my $parent = $self->lookup($prog->id)) {

return ($prog, $self->getHierarchy($parent))

}

else { return $prog }

}

getHierarchy :: Database -> Prog -> [Prog]

getHierarchy db p =

let l = M.lookup p (graph db)

in case l of

Nothing -> [p]

Just (parent) -> p : (getHierarchy db parent)

Get Hierarchyuse experimental ‘signatures’;

use MooX::HandlesVia;

has graph => (

is => 'ro',

isa => HashRef[InstanceOf["Programme"]],

handles_via => 'Hash',

handles => { lookup => ‘get’ }

);

sub getHierarchy($self, $prog) {

if (my $parent = $self->lookup($prog->id)) {

return ($prog, $self->getHierarchy($parent))

}

else { return $prog }

}

Search for a programmesub search ($self, $prog1) {

my sub match ($prog2) {

return unless ref $prog1 eq ref $prog2;

return unless $prog1->id or $prog1->id2;



return unless $prog1->id2 or $prog2->id;

return if $prog1->id and $prog2->id and $prog1->id ne $prog2->id;

return if $prog1->id2 and $prog2->id2 and $prog1->id2 ne $prog2->id2;

return 1;

}

return $self->filter(\&match);

}

Search for a programmeuse experimental 'lexical_subs';

has list => (

is => 'ro',

isa => ArrayRef[InstanceOf["Programme"]],

handles_via => 'Array',

handles => { filter => 'grep'}

);

Search for a programmesearch db p =

filter (match p) (list db)

where

match (Prog t1 _ _) (Prog t2 _ _) | t1 /= t2 = False

match (Prog _ Nothing Nothing) _ = False

match _ (Prog _ Nothing Nothing) = False

match (Prog _ Nothing _) (Prog _ _ Nothing) = False

match (Prog _ _ Nothing) (Prog _ Nothing _) = False

match (Prog _ (Just p1) _) (Prog _ (Just p2) _) | p1 /= p2 = False

match (Prog _ _ (Just a1)) (Prog _ _ (Just a2)) | a1 /= a2 = False

match _ _ = True

Thanks!@osfameron

https://github.com/osfameron/haskell-perl

Software

Is Haskell an acceptable Perl?