The document discusses functional programming concepts in Perl like currying, partial application, and operator overloading using modules like Sub::Curried and Sub::Section. It provides examples of defining functions to add numbers, converting between Celsius and Fahrenheit, and composing functions in a point-free style.

1. osfameron Functional Pe(a)rls

2. Functional pe(a)rls World tour! IPW 2008 LPW 2008 NWE.pm May 2009 YAPC::EU Lisbon 2009 version 4 Osfameron

3. Functional Programming What is it?

4. Functional Programming About functions?

5. Functional Programming About functions? (like Object-oriented is about objects?)

6. Functional Programming everything's a function!

7. Functional Programming 1 + 2

8. Functional Programming 1 + 2 Spot the function?

9. Functional Programming 1 + 2 Spot the function?

10. Functional Programming 1 + 2 first class?

11. Functional Programming 1 + 2

12. Functional Programming 1 + 2 op<+>

13. OPERATORS UNITE! STOP this discrimation now!

15. Cry!

16. Steal from Haskell!

18. (+) ← ref to add

21. $add->(1, 2); # 3

22. YAY!

24. op('+')

26. (But better than source filters)

29. MooseX::Declare

30. Sub::Auto

32. Gives nice syntax, using Devel::Declare

33. op (+)

35. Gives nice syntax, using Devel::Declare

36. op (Bwahaha!) (+) Devel::Declare custom parser hook can inject code etc.

38. Gives nice syntax, using Devel::Declare

39. op (Bwahaha!) ('+')

41. Gives nice syntax, using Devel::Declare

42. Op ('+') # Perl is none the wiser Tee hee!

45. changing the source as you compile

46. horrible perl tricks to get methods installed, and braces closed

47. mst++, rafl++

48. Sections

51. (+1) is

53. (+1) 8 # 9

56. 1 arg at a time

59. (That's 2 arguments)

61. (That's 2 arguments)

62. add(5) ...

64. (That's 2 arguments)

65. add(5) # $left is bound to 5

67. (That's 2 arguments)

68. add(5) # $left is bound to 5 ->(6); # 11

70. sub add { my $left = shift; return sub { my $right = shift; return $left + $right; } }

72. sub add { my $left = shift; return sub { my $right = shift; return $left + $right; } }

73. Not pretty or convenient though

75. Gives nice syntax, using Devel::Declare

76. sub add ($left, $right) { return $left + $right; }

78. Gives nice syntax, using Devel::Declare

79. curry add ($left, $right) { return $left + $right; }

81. Gives nice syntax, using Devel::Declare

82. curry (bwahaha!) add ($left, $right) { return $left + $right; }

84. curry add { return ROUTINE unless @_; check_args(2, @_); my $f = sub { my $f = sub { ... } $f = $f->(shift) for @_; return $f; }

86. curry add { return ROUTINE unless @_ ; check_args(2, @_); my $f = sub { my $f = sub { ... } $f = $f->(shift) for @_; return $f; }

89. add(5); # function that adds 5

91. add(5); # function that adds 5

92. add(); # function that adds...

94. add(5); # function that adds 5

95. add(); # function that adds...

96. i.e = amp;add

98. curry add { return ROUTINE unless @_; check_args(2 , @_); my $f = sub { my $f = sub { ... } $f = $f->(shift) for @_; return $f; }

101. curry add { return ROUTINE unless @_; check_args(2, @_); my $f = sub { my $f = sub { ... } $f = $f->(shift) for @_; return $f; }

103. add(1)->(2)

107. ... turns out to be useful/elegant in Haskell

109. ... turns out to be useful/elegant in Haskell

110. (actually, similar techniques are used in Perl)

114. sub add_accessor { my ( $self , $accessor) = @_; ....

117. *{$CALLER::has} = mk_has();

119. *{$CALLER::has} = mk_has();

120. *{$CALLER::has} = has($CALLER);

125. my $add = op(+); # YAY

127. my $add = op(+); # YAY

128. my $add2 = op(+2); # take THAT, Haskell!

131. (1-)

133. (1-) # minus(1)

135. (1-) # minus(1)

137. (1-) # minus(1)

140. Minus (3, 1) # 2

141. flip(minus)->(3, 1) # -2;

143. my $prev = flip(minus)->(1);

145. $right = 5

146. minus($right=5, $left=1); # 4

150. $greet->(“World”); # “Hello World”

152. > (2,4,6,8)

154. > (2,4,6,8)

158. > (2,4,6,8)

162. Perl's $_ is a horrible hack around not doing currying properly

164. Perl's $_ is a horrible hack around not doing currying properly

165. Why am I still programming this silly language? ;-)

167. Perl's $_ is a horrible hack around not doing currying properly

168. Why am I still programming this silly language? ;-)

169. Oh yes! - because I can change it.

171. fmap sub { … }, @list;

172. fmap op(+2), @list;

174. fmap sub { … }, @list;

175. fmap op(+2), @list;

176. (those will all work anyway)

178. fmap sub { … }, @list;

179. fmap op(+2), @list;

180. (those will all work anyway)

181. fmap { uc } @list;

183. fmap sub { … }, @list;

184. fmap op(+2), @list;

185. (those will all work anyway)

186. fmap (bwahahaha!) { uc } @list;

188. fmap sub { … }, @list;

189. fmap op(+2), @list;

190. (those will all work anyway)

191. fmap sub { uc } , @list;

193. fmap sub { … }, @list;

194. fmap op(+2), @list;

195. (those will all work anyway)

196. fmap underscorify( sub { uc } ) , @list;

201. my $f2c = sub { op(*5/9)->( op(-32)->(shift)) };

203. my $f2c = sub { op(*5/9)->( op(-32)->(shift)) };

204. MY EYES!

206. my $f2c = sub { op(*5/9) ->( op(-32) ->(shift)) };

208. my $f2c = sub { op(*5/9) ->( op(-32) ->(shift)) };

209. Never mind the boilerplate...

211. my $f2c = op(*5/9) << op(-32)

212. Composition

214. my $f2c = op(*5/9) << op(-32)

215. Sub::Compose

217. my $f2c = op(*5/9) << op(-32)

220. my $f2c = op(*5/9) << op(-32)

222. ... autobox?

224. (obfu for maths types)

226. $square->(4); # 16

228. my $square = op(*) << dup;

229. $square->(4); # 16

231. my $dup = op(x 2); # ?

233. my $dup = op(x 2); “$arg$arg”

236. op[x 2] # thanks mst

237. Some light relief

238. Some light relief Monads

240. “Category theory”

242. “Category theory”

243. Very clever people rave about them being useful

245. “Category theory”

246. Very clever people rave about them being useful

247. Have a reputation for being hard to understand

248. Monad tutorials

249. Monad tutorials

250. Monad tutorials

251. Monad tutorials

252. Monad tutorials Step 1: Write Monad Tutorial

253. Monad tutorials Step 2: ???

254. Monad tutorials Step 3: Profit!

257. YAY!

259. Sequences of commands?

260. Sequencing my $x = 1; my $y = 2; my $z = $x * $y; say “$x * $y = $z”;

261. Sequencing my $x = 1; my $y = 2; my $z = $x * $y; say “$x * $y = $z”;

262. Sequencing my $x = 1; my $y = 2; my $z = $x * $y; say “$x * $y = $z”;

263. Sequencing my @seq = sub { my $x = 1 }, sub { my $y = 2 }, sub { my $z = $x * $y }, sub { say &quot;$x * $y = $z&quot; };

264. Sequencing my @seq = sub { my $x = 1 }, sub { my $y = 2 }, sub { my $z = $x * $y }, sub { say &quot;$x * $y = $z&quot; }; # Global symbol &quot;$x&quot; requires explicit package name at ...

265. Nesting my $x = 1; my $y = 2; my $z = $x * $y; say “$x * $y = $z”;

266. Nesting sub { my $x = 1; sub { my $y = 2; sub { my $z = $x * $y; sub { say &quot;$x * $y = $z&quot;; }->() }->() }->() }->();

267. Monadic programming is impractical in Perl... only because of syntactic issues – Mark Jason Dominus http://perl.plover.com/classes/fp/samples/slide027.html

270. Deparse and source text munging

272. mdo { my $x = mbind(1); my $y = mbind(2); my $z = mbind($x + $y); say “$x * $y = $z”; }

274. mdo { my $x = mbind(1); my $y = mbind(2); my $z = mbind($x + $y); say “$x * $y = $z”; }

275. mdo introduces the block

276. mbind gives us a hook to rotate around

281. for trivial cases

282. (a bit fragile)

284. for trivial cases

285. (a bit fragile)

286. though localised to mdo { ... }

288. mdo { mbind $x = 1; mbind $y = 2; mbind $z = $x + $y; say “$x * $y = $z”; }

290. mdo { mbind $x = 1; mbind $y = 2; mbind $z = $x + $y; say “$x * $y = $z”; }

292. mdo { mbind 1, sub { my $x = shift; mbind 2, sub { my $y = shift; mbind $x + $y, sub { my $z = shift; say “$x * $y = $z”; } ...

294. scope_inject

295. B::Hooks::EndOfScope

296. Use to inject a ; at the end of method declarations:

297. method foo ($x) { print $x; } # look Ma, no semicolon!

299. mdo { mbind 1, sub { my $x = shift; mbind 2, sub { my $y = shift; mbind $x + $y, sub { my $z = shift; say “$x * $y = $z”; } # adds a closing brace }

301. mdo { mbind 1, sub { my $x = shift; mbind 2, sub { my $y = shift; mbind $x + $y, sub { my $z = shift; say “$x * $y = $z”; } } # adds a closing brace }

303. mdo { mbind 1, sub { my $x = shift; mbind 2, sub { my $y = shift; mbind $x + $y, sub { my $z = shift; say “$x * $y = $z”; } } } # adds a closing brace }

305. mdo { mbind 1, sub { my $x = shift; mbind 2, sub { my $y = shift; mbind $x + $y, sub { my $z = shift; say “$x * $y = $z”; } } } } # closes block

307. mdo { mbind $x = 1; mbind $y = 2; mbind $z = $x + $y; say “$x * $y = $z”; }

309. in pure Perl!

312. Imperative languages have always done this

314. mdo { mbind $x = 1; mbind $y = 2; mbind $z = $x + $y; say “$x * $y = $z”; }

316. mdo { mbind $x = 1; mbind $y = 2; mbind $z = $x + $y; say “$x * $y = $z”; }

318. mdo { mbind $x = 1 ; mbind $y = 2 ; mbind $z = $x + $y ; say “$x * $y = $z”; }

320. mdo { mbind $x = 1 ; mbind $y = 2 ; mbind $z = $x + $y ; say “$x * $y = $z”; }

321. Programmable semicolon!

323. mdo (Maybe) { mbind $FH = m_open('<', $file) ; mbind $line = <$FH> ; mbind $val = lookup(h, $line) ; say “Found $val!”; }

325. mdo (Maybe) { mbind $FH = m_open('<', $file) ; mbind $line = <$FH> ; mbind $val = lookup(h, $line) ; say “Found $val!”; }

326. Will give up if can't open file, read a line from it, or look it up in a hash

328. mdo (Maybe) { mbind $FH = m_open('<', $file) ; mbind $line = <$FH> ; mbind $val = lookup(h, $line) ; say “Found $val!”; }

329. Compare chain of if (foo) { if (bar) { ...

330. or eval { ... }

331. Maybe $FH = open($file) $line = <$FH> $val = lookup ( $line ) say “Found $val”

332. Maybe $FH = open($file) $line = <$FH> $val = lookup ( $line ) say “Found $val” ?

333. Sequence

334. Maybe ? ? ?

335. Multiple (List)

336. List $x = [1..10] $y = [1..10] guard $x+$y == 10 say “$x+$y=10”

338. mdo { mbind $x = [1..10] ; mbind $y = [1..10] ; mbind guard $x+$y == 10 ; say “$x+$y=10”; }

339. Run every $x against every $y and filter

341. mdo { mbind $x = [1..10] ; mbind $y = [1..10] ; mbind guard $x+$y == 10 ; say “$x+$y=10”; }

342. 1+9=10

343. 2+8=10

344. ...

346. mdo { mbind $x = [1..10] ; mbind $y = [1..10] ; mbind guard $x+$y == 10 ; say “$x+$y=10”; }

347. just like SQL

348. or LINQ

350. mcomp ($x <- [1..10]; $y <- [1..10]; $x+y==10) { say “$x+$y=10” }

352. We're actually calling mbind on a list

354. We're actually calling mbind on a list

355. autobox

356. Continuations call_cc (amp;somefunc, ... ... ... )

357. Continuations somefunc

358. (clonable!) Continuations Somefunc for 1..3 {...}

361. $x ← foo(); # monadic

362. bar(); # also monadic!

363. my $x = 12; # “normal” value

364. (e.g. no more 'mbind' keyword)

366. But you can take it surprisingly far

367. (CPAN++)

369. Error handling

370. SQL generation

372. Nicely wrapped implementation will be ready soon....

374. Nicely wrapped implementation will be ready soon....

375. Github: Acme::Monads – patches welcome

378. CPAN