• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Fundamentalist functional programming
 

Fundamentalist functional programming

on

  • 563 views

 

Statistics

Views

Total Views
563
Views on SlideShare
563
Embed Views
0

Actions

Likes
0
Downloads
14
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Fundamentalist functional programming Fundamentalist functional programming Presentation Transcript

    • 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
    • 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”); Console.WriteLine(“ha”); != Console.WriteLine(“ha”); var x = Console.ReadLine(); var y = x+x; != var y = Console.ReadLine() + Console.ReadLine()
    • Doing IO is a side-effect let date = DateTime.Now() in (date, date)  ( DateTime.Now() , DateTime.Now() ) DateTime.Now is not a mathematical function
    • If I cannot even do IO Fundamentalist Functional Programming is just academic nonsense
    • Don’t eat The Yellow Snow!
    • Lazy evaluation and side-effects static bool LessThanThirty( in t x) { Console.Write(&quot;{0}? Less than 30;&quot;,x); return x < 30; } static bool MoretHanTwenty( int x) { Console.Write(&quot;{0}? More than 20;&quot;,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(&quot;[{0}];&quot;,r); Order of side effects? C#
    •  
    • let lessThanThirty(x:int)= begin Console.WriteLine (&quot;{0} less than 30?&quot;, x); x < 30; end let moreThanTwenty(x:int)= begin Console.WriteLine (&quot;{0} more than 20?&quot;, x); x > 20; end 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 then yield x } for r in q1 do Console.WriteLine(&quot;> {0},&quot;, r) F# Lazy comprehensions
    • let lessThanThirty(x:int)= begin Console.WriteLine (&quot;{0} less than 30?&quot;, x); x < 30; end let moreThanTwenty(x:int)= begin Console.WriteLine (&quot;{0} more than 20?&quot;, x); x > 20; end 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 then yield x ] for r in q1 do Console.WriteLine(&quot;> {0},&quot;, r) F# Eager comprehensions
    • 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 Exceptions
    •  
    • Func< string > GetContents = null ; using ( var file = FileSystem.OpenTextFileReader(@&quot;…&quot;)) { GetContents = () => file.ReadToEnd(); } // surprise! an exception Console.WriteLine(GetContents()); Disposing resources
    • var DelayedActions = new List<Func<int>>(); var s = &quot;&quot;; 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); Variable Instantiation Prints 777
    • var DelayedActions = new List<Func<int>>(); var s = &quot;&quot;; 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); Variable Instantiation Prints 456 Prints 666 C# JavaScript
    • var DelayedActions = new List<Func<int>>(); var s = &quot;&quot;; 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); Variable Instantiation Prints 666
    • 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); Object creation
    • 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()}, receive {return, Value} -> Value end. dispose_cell(Cell) -> Cell!{dispose}. Concurrency
    • 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 .
    •  
    • GET …/person/age… GET …/clock/seconds… few interesting functions are idempotent *not* idempotent *not* pure
    • 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>(); } “ Dishonest” types Not parametric!
    • HOT Languages To the rescue
    • lessThanThirty x = do { putStrLn $ (show x)++&quot; less than 30?&quot; ; return $ x < 30 } moreThanTwenty x = do { putStrLn $ (show x)++&quot; more than 20?&quot; ; 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
    • unsafePerformIO :: IO a -> a unsafeCast :: a -> b unsafeCast x = unsafePerformIO $ do{ writeIORef castref x ; readIORef castref } castref = unsafePerformIO $ do{ newIORef undefined } Forget about effects? Forget it!
    • 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 !!!!!!!!!!!!!!!
    • Values vs Computation How to turn something mutable into something immutable? Time changes, the clock does not
    • … 9:15 AM 9:16 AM 9:17 AM 9:19 AM 9:29 AM 9:21 AM 9:22 AM 9:23 AM 9:24 AM 9:25 AM 9:26 AM 9:27 AM 9:28 AM 9:29 AM 9:30 AM … It’s just a collection All problems in computer science can be solved by another level of indirection D. Wheeler
    • Mathematics is always right
    • Multithreading  STM<T> Destructive updates  IO<T> Reflection  Mirror<T> Exceptions  Throws<T> Only one way to be pure, But many ways to be impure
    • The “M” word Monads M<A> A computation that produces a value of type A with side-effects described by M M  IO Exception Animation Collection
    • IO 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 Side-effecting computation that yields a value of type a
    • Can Normal Programmers Understand Fundamentalist Functional Programming?
    •  
    • LINQ Monads are the secret sauce behind LINQ IEnumerable <S> SelectMany<T,S>( IEnumerable<T > src, Func<T, IEnumerable<S >> selector ) Bind
    • Java Throws clause void Foo( string s) throws Exception Explicit Effects
    • 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
    •  
    •