F#-What is F#

What is F#

• F# is a functional programming language (函数式编程)that makes it easy to write correct and maintainable code.

  F# programming primarily involves defining types and functions that are type-inferred and generalized automatically. 

• This allows your focus to remain on the problem domain and manipulating its data, rather than the details of programming.

  open System // Gets access to functionality in System namespace.
  
  // Defines a function that takes a name and produces a greeting.
  let getGreeting name =
      sprintf "Hello, %s! Isn't F# great?" name
  
  [<EntryPoint>]
  let main args =
      // Defines a list of names
      let names = [ "Don"; "Julia"; "Xi" ]
  
      // Prints a greeting for each name!
      names
      |> List.map getGreeting
      |> List.iter (fun greeting -> printfn "%s" greeting)
  
      0
  

  F# has numerous features, including:

  A full set of features are documented in the F# language reference.

  Rich data types

  Data types such as Records and Discriminated Unions let you represent complex data and domains.

  F#复制

  // Group data with Records
  type SuccessfulWithdrawal = {
      Amount: decimal
      Balance: decimal
  }
  
  type FailedWithdrawal = {
      Amount: decimal
      Balance: decimal
      IsOverdraft: bool
  }
  
  // Use discriminated unions to represent data of 1 or more forms
  type WithdrawalResult =
      | Success of SuccessfulWithdrawal
      | InsufficientFunds of FailedWithdrawal
      | CardExpired of System.DateTime
      | UndisclosedFailure
  

  F# records and discriminated unions are non-null, immutable, and comparable by default, making them very easy to use.

  Enforced correctness with functions and pattern matching

  F# functions are easy to declare and powerful in practice. When combined with pattern matching, they allow you to define behavior whose correctness is enforced by the compiler.

  F#复制

  // Returns a WithdrawalResult
  let withdrawMoney amount = // Implementation elided
  
  let handleWithdrawal amount =
      let w = withdrawMoney amount
  
      // The F# compiler enforces accounting for each case!
      match w with
      | Success s -> printfn "Successfully withdrew %f" s.Amount
      | InsufficientFunds f -> printfn "Failed: balance is %f" f.Balance
      | CardExpired d -> printfn "Failed: card expired on %O" d
      | UndisclosedFailure -> printfn "Failed: unknown :("
  

  F# functions are also first-class, meaning they can be passed as parameters and returned from other functions.

  Functions to define operations on objects

  F# has full support for objects, which are useful data types when you need to blend data and functionality. F# functions are used to manipulate objects.

  F#复制

  type Set<'T when 'T: comparison>(elements: seq<'T>) =
      member s.IsEmpty = // Implementation elided
      member s.Contains (value) =// Implementation elided
      member s.Add (value) = // Implementation elided
      // ...
      // Further Implementation elided
      // ...
      interface IEnumerable<‘T>
      interface IReadOnlyCollection<‘T>
  
  module Set =
      let isEmpty (set: Set<'T>) = set.IsEmpty
  
      let contains element (set: Set<'T>) = set.Contains(element)
  
      let add value (set: Set<'T>) = set.Add(value)
  

  Rather than writing code that is object-oriented, in F#, you will often write code that treats objects as another data type for functions to manipulate. Features such as generic interfaces, object expressions, and judicious use of members are common in larger F# programs.

  Next steps

  To learn more about a larger set of F# features, check out the F# Tour.

  • Lightweight syntax
  • Immutable by default
  • Type inference and automatic generalization
  • First-class functions
  • Powerful data types
  • Pattern matching
  • Async programming