F# 简单的计算一例

2. // F# Visual Studio Sample File
3. //
4. // This file contains some sample constructs to guide you through the
5. // primitives of F#.
6. //
7. // Contents:
8. //   - Simple computations
9. //   - Functions on integers.  
10. //   - Tuples 
11. //   - Strings
12. //   - Lists
13. //   - Arrays
14. //   - Functions
16. // Simple computations   简单的计算
17. // ---------------------------------------------------------------
18. // Here is a simple computation.  Note how code can be documented
19. // with '///' comments.  You can use the extra --html-* command line
20. // options to generate HTML documentation directly from these comments.
22. /// The position of 'c' in a sample string
23. let posc = String.index "abcdef" 'c'
25.   // Try re-typing the above line to see intellisense in action.
26.   // Try ctrl-J on (partial) identifiers.
28. // Simple arithmetic:
29. let xA = 1
30. let xB = 2
31. let xC = xA + xB
32. let twist x = 10 - x
33. do  Printf.printf "res = %d/n" (twist (xC+4))
34.   // note: let binds values and functions
35.   // note: do <expr> evaluates expression 
37. do Printf.printf "stop"
38. // Functions on integers.  
39. // ---------------------------------------------------------------
41. let inc x = x + 1  //自增1 函数
42. let rec fact n = if n=0 then 1 else n * fact (n-1)
44. //hsg write line
45. do Printf.printf "inc(4)=%d/n"  (inc 4)
46. do Printf.printf "fact=f(5)=%d/n"  (fact (inc 4))
48. //hsg write line 定义一个函数f(X^2+2X+5)
49. let one_x x=x*x+2*x+5
50. do Printf.printf "one_x(4)=%d/n"  (one_x 4)  //16+8+5=29
52. let one_xy x y=x*x+y*y+5
55. /// Highest-common-factor 
56. let rec hcf a b =           // notice: 2 arguments seperated by spaces
57.   if a=0 then
58.     b
59.   else
60.     if a<b then
61.       hcf a (b-a)           // notice: 2 arguments seperated by spaces
62.     else
63.       hcf (a-b) b
64.   // note: function arguments are usually space seperated.
65.   // note: let rec binds recursive functions.
67.       
68. // Tuples.  These combine values into packets.
69. // ---------------------------------------------------------------
70. let pA = (1,2,3)
71. let pB = (1,"fred",3.1415)
72. let swap (a,b) = (b,a)
74. /// Note: hcf2 takes one argument which is in fact a tuple.
75. let rec hcf2 (a,b) = 
76.   if a = 0 then b
77.   else if a<b then hcf2 (a,b-a)
78.   else hcf2 (a-b,a)
81. // Booleans.
82. // ---------------------------------------------------------------
84. let bA = true
85. let bB = false
86. let bC = not bA && (bB || false)
88. //hsg write line
89. let hsgA=true
90. let hsgB=false
91. let hsgC=not hsgA && (hsgB || false)
94. // Strings.
95. // ---------------------------------------------------------------
97. let sA  = "hello"
98. let sB  = "world"
99. let sC  = sA + " " + sB
100. let sC2 = String.concat " " [sA;sB]
101. do  Printf.printf "sC = %s, sC2 = %s/n" sC sC2
102. let s3 = Printf.sprintf "sC = %s, sC2 = %d/n" sC sC2.Length
104. //hsg write line
105. let h_sA="hello"
106. let h_sb="world"
107. let h_sC=h_sA+"  "+h_sb
108. let h_sC2=String.concat "" [h_sA;h_sb]
109. do Printf.printf "sC=%s,sC2=%s/n" h_sC h_sC2
113. // Functional Lists.
114. // ---------------------------------------------------------------
116. let xsA = [ ]           // empty list
117. let xsB = [ 1;2;3 ]     // list of 3 ints
118. let xsC = 1 :: [2;3]    // :: is cons operation.
120. do print_any xsC
122. let rec sumList xs =
123.   match xs with
124.   | []    -> 0
125.   | y::ys -> y + sumList ys
126.     
127. let y   = sumList [1;2;3]  // sum a list
128. let xsD = xsA @ [1;2;3]    // append
129. let xsE = 99 :: xsD        // cons on front
132. // Mutable Arrays, a primitive for efficient computations
133. // ---------------------------------------------------------------
135. let arr = Array.create 4 "hello"
136. do  arr.(1) <- "world"
137. do  arr.(3) <- "don"
138. let nA = Array.length arr  // function in Array module/class
139. let nB = arr.Length        // instance method on array object
141. let front = Array.sub arr 0 2
142.   // Trying re-typing the above line to see intellisense in action.
143.   // Note, ctrl-J on (partial) identifiers re-activates it.
145. // Other common data structures
146. // ---------------------------------------------------------------
148. // See namespaces 
149. //   System.Collections.Generic
150. //   Microsoft.FSharp.Collections
151. //   Hashtbl
152. //   Set
153. //   Map
156. // Functions
157. // ---------------------------------------------------------------
159. let inc2 x = x + 2              // as a function definition
160. let inc3   = fun x -> x + 3     // as a lambda expression
162. let ysA = List.map inc2 [1;2;3]
163. let ysB = List.map inc3 [1;2;3]
164. let ysC = List.map (fun x -> x+4) [1;2;3]
166. // Pipelines:
167. let pipe1 = [1;2;3] |> List.map (fun x -> x+4) 
168. let pipe2 = 
169.   [1;2;3] 
170.   |> List.map (fun x -> x+4) 
171.   |> List.filter (fun x -> x>5) 
173. // Composition pipelines:
174. let processor = List.map (fun x -> x+4) >> List.filter (fun x -> x>5) 
176. // Types - datatypes
177. // ---------------------------------------------------------------
179. type expr = 
180.   | Num of int
181.   | Add of expr * expr
182.   | Sub of expr * expr
183.   | Mul of expr * expr
184.   | Div of expr * expr
185.   | Var of string
186.   
187. let lookup id (env : (string * int) list) = List.assoc id env
188.   
189. let rec eval env exp = match exp with
190.   | Num n -> n
191.   | Add (x,y) -> eval env x + eval env y
192.   | Sub (x,y) -> eval env x - eval env y
193.   | Mul (x,y) -> eval env x * eval env y
194.   | Div (x,y) -> eval env x / eval env y
195.   | Var id    -> lookup id env
196.   
197. let envA = [ "a",1 ;
198.              "b",2 ;
199.              "c",3 ]
200.              
201. let expT1 = Add(Var "a",Mul(Num 2,Var "b"))
202. let resT1 = eval envA expT1
205. // Types - records
206. // ---------------------------------------------------------------
208. type card = { name  : string;
209.               phone : string;
210.               ok    : bool }
211.               
212. let cardA = { name = "Alf" ; phone = "+44.1223.000.000" ; ok = false }
213. let cardB = {cardA with phone = "+44.1223.123.456"; ok = true }
214. let string_of_card c = 
215.   c.name + " phone: " + c.phone + (if not c.ok then " (unchecked)" else "")
218. // Here's a longer construction syntax should you get name conflicts:
219. let cardC = {  new card 
220.                with name  = "Alf" 
221.                and  phone = "+44.1223.000.000" 
222.                and  ok = false }
226. // Types - interfaces, which are like records of functions
227. // ---------------------------------------------------------------
229. type IPeekPoke = interface
230.   abstract member Peek: unit -> int
231.   abstract member Poke: int -> unit
232. end
235.               
237. // Types - classes
238. // ---------------------------------------------------------------
240. type widget = class
241.   val mutable state: int 
242.   member x.Poke(n) = x.state <- x.state + n
243.   member x.Peek() = x.state 
244.   member x.HasBeenPoked = (x.state <> 0)
245.   new() = { state = 0 }
246. end
247.               
248. // Types - classes with interface implementations
249. // ---------------------------------------------------------------
251. type wodget = class
252.   val mutable state: int 
253.   interface IPeekPoke with 
254.     member x.Poke(n) = x.state <- x.state + n
255.     member x.Peek() = x.state 
256.   end
257.   member x.HasBeenPoked = (x.state <> 0)
258.   new() = { state = 0 }
259. end
261. do Printf.printf "stop"
262.