Disclaimer: The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

What is a XXX Language? XXX = dynamic XXX = imperative XXX = OO

A language where functions are first-class citizens What is a Functional Language A language where functions are first-class citizens

EWD 1073

Easy like Sunday morning

Dan Meyer WTF went wrong?

Doing IO is a side-effect Console.WriteLine(“ha”); != var x = Console.ReadLine(); var y = x+x; != var y = Console.ReadLine() + Console.ReadLine()

DateTime.Now is not a mathematical function Doing IO is a side-effect let date = DateTime.Now() in (date, date)  ( DateTime.Now() , DateTime.Now() ) DateTime.Now is not a mathematical function

Functional Programming is just academic nonsense If I cannot even do IO Fundamentalist Functional Programming is just academic nonsense

Don’t eat The Yellow Snow!

C# Lazy evaluation and side-effects static bool LessThanThirty(int x) { Console.Write("{0}? Less than 30;",x); return x < 30; } static bool MoretHanTwenty(int x) { Console.Write("{0}? More than 20;",x); return x > 20; } var q0 = from x in new[]{ 1, 25, 40, 5, 23 } where LessThanThirty(x) select x; var q1 = from x in q0 where MoreThanTwenty(x) select x; foreach (var r in q1) Console.WriteLine("[{0}];",r); Order of side effects?

F# Lazy comprehensions let lessThanThirty(x:int)= begin Console.WriteLine ("{0} less than 30?", x); x < 30; end let moreThanTwenty(x:int)= begin Console.WriteLine ("{0} more than 20?", x); x > 20; let q0 = seq { for x in [1; 25; 40; 5; 23] do if lessThanThirty x then yield x } let q1 = seq { for x in q0 do if moreThanTwenty x for r in q1 do Console.WriteLine("> {0},", r) F# Lazy comprehensions

F# Eager comprehensions let lessThanThirty(x:int)= begin Console.WriteLine ("{0} less than 30?", x); x < 30; end let moreThanTwenty(x:int)= begin Console.WriteLine ("{0} more than 20?", x); x > 20; let q0 = [ for x in [1; 25; 40; 5; 23] do if lessThanThirty x then yield x ] let q1 = [ for x in q0 do if moreThanTwenty x for r in q1 do Console.WriteLine("> {0},", r) F# Eager comprehensions

Exceptions var xs = new[]{ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; IEnumerable<int> q = null; try { q = from x in xs select 1/x; } catch { q = new int[]; } foreach(var z in q) Console.WriteLine(z): // throws here

Disposing resources Func<string> GetContents = null; using( var file = FileSystem.OpenTextFileReader(@"…")) { GetContents = () => file.ReadToEnd(); } // surprise! an exception Console.WriteLine(GetContents());

Variable Instantiation var DelayedActions = new List<Func<int>>(); var s = ""; for (var i = 4; i < 7; i++) { DelayedActions.Add(delegate(){ return i; }); } for (var k = 0; k < DelayedActions.Count; k++) s += DelayedActions[k](); Console.WriteLine(s); Prints 777

Variable Instantiation var DelayedActions = new List<Func<int>>(); var s = ""; for (var i = 4; i < 7; i++) { var j = i; DelayedActions.Add(delegate(){ return j; }); } for (var k = 0; k < DelayedActions.Count; k++) s += DelayedActions[k](); Console.WriteLine(s); Prints 456 C# Prints 666 JavaScript

Variable Instantiation var DelayedActions = new List<Func<int>>(); var s = ""; var j; for (var i = 4; i < 7; i++) { j = i; DelayedActions.Add(delegate(){ return j; }); } for (var k = 0; k < DelayedActions.Count; k++) s += DelayedActions[k](); Console.WriteLine(s); Prints 666

Object creation var o1 = new object(); //58225482, for instance Console.WriteLine(o1.GetHashCode()); var o2 = new object(); // 54267293, for instance Console.WriteLine(o2.GetHashCode()); Debug.Assert(o1 != 02);

Concurrency new_cell(X) -> spawn(fun() -> cell(X) end). cell(Value) -> receive {set, NewValue} -> cell(NewValue); {get, Pid} -> Pid!{return, Value}, cell(Value); {dispose} -> {} end. set_cell(Cell, NewValue) -> Cell!{set, NewValue}. get_cell(Cell) -> Cell!{get, self()}, {return, Value} -> Value dispose_cell(Cell) -> Cell!{dispose}.

Page 165: There is a subtle error in on_exit and keep_alive … Write your code such that race conditions cannot happen. … Fortunately, the OTP libraries have code for building servers, supervisor trees, and so on. These libraries have been well tested and should not suffer from any race conditions.

few interesting functions are idempotent *not* idempotent *not* pure few interesting functions are idempotent GET …/person/age… GET …/clock/seconds…

“Dishonest” types static T Identity<T>(this T me) { Not parametric! static T Identity<T>(this T me) { if(me.GetType() == typeof(Button)) throw new Exception(); var mini_me = me as string; if(mini_me != null) return “hello world”; Console.WriteLine(me.ToString()); return Activator.CreateInstance<T>(); }

HOT Languages To the rescue

Haskell lessThanThirty x = do { putStrLn $ (show x)++" less than 30?" ; return $ x < 30 } moreThanTwenty x = do { putStrLn $ (show x)++" more than 20?" ; return $ x > 20 q0 = [ x | x <- [1, 25, 50, 5, 23 ] , lessThanThirty x ] q1 = [ x | x <- q0 , moreThanTwenty 20 ] Couldn't match expected type `Bool' against inferred type `IO Bool' In a stmt of a list comprehension: lessThanThirty x In the expression: [x | x <- [1, 25, 50, ....], lessThanThirty x] In the definition of `q0': q0 = [x | x <- [1, 25, ....], lessThanThirty x Haskell

Forget about effects? Forget it! unsafePerformIO :: IO a -> a unsafeCast :: a -> b unsafeCast x = unsafePerformIO $ do{ writeIORef castref x ; readIORef castref } castref = unsafePerformIO $ do{ newIORef undefined }

Cover up effects

Remove all effects (cannot make language more powerful by removing features)

Don’t fight effects Embrace and extend

Mens sana in corpore sano

Mistake DateTime.Now() DateTime Type error !!!!!!!!!!!!!!!

Time changes, the clock does not Values vs Computation How to turn something mutable into something immutable? Time changes, the clock does not

It’s just a collection … 9:15 AM 9:16 AM 9:17 AM 9:19 AM 9:29 AM All problems in computer science can be solved by another level of indirection D. Wheeler

Mathematics is always right

But many ways to be impure Only one way to be pure, But many ways to be impure Multithreading  STM<T> Exceptions  Throws<T> Reflection  Mirror<T> Destructive updates  IO<T>

The “M” word M  IO Exception Animation Collection Monads M<A> A computation that produces a value of type A with side-effects described by M

Side-effecting computation that yields a value of type a data IO a putChar :: Char -> IO () getChar :: IO Char newIORef :: a -> IO (IORef a) readIORef :: IORef a -> IO a writeIORef :: IORef a -> a -> IO () forkIO :: IO a -> IO ThreadID

Fundamentalist Functional Can Normal Programmers Understand Fundamentalist Functional Programming?

LINQ Monads are the secret sauce behind LINQ Bind IEnumerable<S> SelectMany<T,S>( IEnumerable<T> src, Func<T, IEnumerable<S>> selector )

Java Throws clause void Foo(string s) throws Exception Explicit Effects

Abstract from evaluation order Make all effects explicit ==> Fundamentalist Functional Programming Abstract from evaluation order Make all effects explicit ==> Compiler can freely rearrange code Runtime can execute in code any order Call-by-name, or call-by-value version?

Call To Action Buy Graham Hutton’s book Nudge and nag MS to produce a fundamentalist functional language

Buy Bryan John & Don’s book Nudge and nag MS to produce a fundamentalist functional language

Thank You