F# Succinct, Expressive, Functional презентация

F#

anyway?

static int a()
{
return 2;
}
static void Main(string[] args)
{
Console.WriteLine(a);
}
}
}

More Noise
Than Signal!

Command(fun rover -> rover.Accelerate(-1.0))

let TurnLeftCommand  =
Command(fun rover -> rover.Rotate(-5.0))
 

Pain

   abstract class Command
    {
        public virtual void Execute();
    }
    abstract class MarsRoverCommand : Command
    {
        protected MarsRover Rover { get; private set; }
 
        public MarsRoverCommand(MarsRover rover)
        {
            this.Rover = rover;
        }
    }
    class BreakCommand : MarsRoverCommand
    {
        public BreakCommand(MarsRover rover)
            : base(rover)
        {
        } 
        public override void Execute()
        {
            Rover.Rotate(-5.0);
        }
    }
class TurnLeftCommand : MarsRoverCommand
    {
        public TurnLeftCommand(MarsRover rover)
            : base(rover)
        {
        }
        public override void Execute()
        {
            Rover.Rotate(-5.0);
        }
    }

  
    public UnaryOp(Expr first)   
    {   
        this.First = first;   
    }   
}   
  
public abstract class BinExpr : Expr   
{   
    public Expr First { get; private set; }   
    public Expr Second { get; private set; }   
  
    public BinExpr(Expr first, Expr second)   
    {   
        this.First = first;   
        this.Second = second;   
    }   
}   
  
public class TrueExpr : Expr { }   
  
public class And : BinExpr   
{   
    public And(Expr first, Expr second) : base(first, second) { }   
}
public class Nand : BinExpr   
{   
    public Nand(Expr first, Expr second) : base(first, second) { }   
}   
  
public class Or : BinExpr   
{   
    public Or(Expr first, Expr second) : base(first, second) { }   
}   
  
public class Xor : BinExpr   
{   
    public Xor(Expr first, Expr second) : base(first, second) { }   
}   
  
public class Not : UnaryOp   
{   
    public Not(Expr first) : base(first) { }   
}  
  
 

http://stepheneasey.wordpress.com/tag/c/

f x + f y + f z

Pain

Tuple Rotate(Tuple t)
{
return new Tuple(t.Item3,t.Item1,t.Item2);
}

int Reduce(Func f,Tuple t)
{
return f(t.Item1) + f(t.Item2) + f (t.Item3);
}

task. F# allows you to move smoothly in your programming style... I start with pure functional code, shift slightly towards an object-oriented style, and in production code, I sometimes have to do some imperative programming.

I can start with a pure idea, and still finish my project with realistic code. You're never disappointed in any phase of the project!

Julien Laugel, Chief Software Architect, www.eurostocks.com

1

+ y Addition
x - y Subtraction
x * y Multiplication
x / y Division
x % y Remainder/modulus
-x Unary negation

f(a,b,c) =
let sum = a + b + c
let g(x) = sum + x*x
g(a), g(b), g(c)

Bind a static value

Bind a static function

Bind a local value

Bind a local function

Type inference. The safety of C# with the succinctness of a scripting language

-> x + 1)

let f(x) = x + 1

(f,f)

val f : int -> int

Anonymous
Function value

Declare a
function value

A pair
of function values

predicate = 'a -> bool

send = 'a -> unit

threadStart = unit -> unit

comparer = 'a -> 'a -> int

hasher = 'a -> int

equality = 'a -> 'a -> bool

One simple
mechanism,
many
uses

A function type

fst (x,y) = x

let data = (Some [1;2;3], Some [4;5;6])

match data with
| Some(nums1), Some(nums2) -> nums1 @ nums2
| None, Some(nums) -> nums
| Some(nums), None -> nums
| None, None -> failwith "missing!"

0..1000 ]
[ for x in 0..10 -> (x, x * x) ]
[| for x in 0..10 -> (x, x * x) |]
seq { for x in 0..10 -> (x, x * x) }

Range
Expressions

List via query

Array via query

IEnumerable
via query

Not Mutate

✓ Copy & Update

transfer between threads

Immutable objects can be aliased safely

Immutable objects lead to (different) optimization opportunities

Directory.GetFiles(dir) do
yield file
for sub in Directory.GetDirectories(dir) do
yield! allFiles(sub) ]

allFiles(@"C:\Demo")

Generated Lists

for file in Directory.GetFiles(dir) do
yield file
for sub in Directory.GetDirectories(dir) do
yield! allFiles(sub) }

allFiles(@"C:\WINDOWS")
|> Seq.take 100
|> show

On-demand sequences

Pipelines

{
static int a()
{
return 2;
}

static void Main(string[] args)
{
Console.WriteLine(a);
}
}
}

Looks Weakly typed?
Maybe Dynamic?

Weakly Typed? Slow?

let internalFunction args = expr
let mutable internalState = expr

member x.Prop1 = expr
member x.Meth2 args = expr

Constructing Objects
new FileInfo(@"c:\misc\test.fs")

dx

member v.DY = dy

member v.Length = sqrt(dx*dx+dy*dy)

member v.Scale(k) = Vector2D(dx*k,dy*k)

Inputs to object construction

Exported properties

Exported method

dx*dx+dy*dy

member v.DX = dx

member v.DY = dy

member v.Length = sqrt(norm2)

member v.Norm2 = norm2

Internal (pre-computed) values and functions

< 50 lines of beautiful functional code>
...

member x.Encode(input: seq) =
encode(input)

member x.Decode(input: seq) =
decode(input)

Immutable inputs

Internal tables

Publish access

= dx

let mutable currDX = dy

member v.DX = currDX

member v.DY = currDY

member v.Move(x,y) =
currDX <- currDX+x
currDY <- currDY+y

Internal state

Publish internal state

Mutate internal state

network, latency)

Translate Good Architecture into Good Code with F#
A great platform
A massive increase in isolation and immutability
A massive reduction in mutation

In parallel programming,

F# is a power tool

for good architects and good developers

Compute 22 and 7 in parallel

Async.Parallel [WebRequest.Async "http://www.live.com";
WebRequest.Async "http://www.yahoo.com";
WebRequest.Async "http://www.google.com" ]

Get these three web pages and wait until all have come back

Visual Studio 2010

Next stop: Visual Studio 2010 Beta 1

Look for it soon!

purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN THIS SUMMARY.