विशेषज्ञ एफ # वेब क्रॉलर उदाहरण

Question

मैं विशेषज्ञ एफ में एक उदाहरण के माध्यम से काम करने के लिए कोशिश कर रहा हूँ #, जो v1.9.2, लेकिन सीटीपी विज्ञप्ति पर आधारित है कि के बाद पर्याप्त उनमें से कुछ भी नहीं है कि बदल गया है अब संकलित करें।

मैं 13-13 लिस्टिंग के साथ कुछ परेशानी में भाग रहा हूं। यहाँ urlCollector वस्तु परिभाषा का टुकड़ा है:

let urlCollector = 
    MailboxProcessor.Start(fun self -> 
     let rec waitForUrl (visited : Set<string>) = 
      async { if visited.Count < limit then 
         let! url = self.Receive() 
         if not (visited.Contains(url)) then 
          do! Async.Start 
           (async { let! links = collectLinks url 
             for link in links do 
             do self <-- link }) 

         return! waitForUrl(visited.Add(url)) } 

      waitForUrl(Set.Empty)) 

मैं संस्करण 1.9.6.16 साथ संकलन कर रहा हूँ, और संकलक thusly शिकायत: पर या में इस बिंदु से पहले

1. अधूरा संरचित निर्माण अभिव्यक्ति [अंतिम माता पिता के बाद]
2. इस 'चलो' के लिए वापसी अभिव्यक्ति में त्रुटि। संभावित गलत इंडेंटेशन [waitForUrl परिभाषित करने के लिए संदर्भित करता है]

कोई भी यहां क्या गलत हो रहा है?

Answer 1

ऐसा लगता है कि अंतिम पंक्ति 4 स्थानों इंडेंट नहीं किए जाने की आवश्यकता है।

संपादित करें: असल में, ऐसा लगता है कि यहां और अधिक चल रहा है। इस मान लिया जाये कि here रूप में एक ही नमूना है, तो यहाँ एक संस्करण मैं सिर्फ 1.9.6.16 रिलीज के साथ सिंक में करने के लिए संशोधित है:

open System.Collections.Generic 
open System.Net 
open System.IO 
open System.Threading 
open System.Text.RegularExpressions 

let limit = 10  

let linkPat = "href=\s*\"[^\"h]*(http://[^&\"]*)\"" 
let getLinks (txt:string) = 
    [ for m in Regex.Matches(txt,linkPat) -> m.Groups.Item(1).Value ] 

let (<--) (mp: MailboxProcessor<_>) x = mp.Post(x) 

// A type that helps limit the number of active web requests 
type RequestGate(n:int) = 
    let semaphore = new Semaphore(initialCount=n,maximumCount=n) 
    member x.AcquireAsync(?timeout) = 
     async { let! ok = semaphore.AsyncWaitOne(?millisecondsTimeout=timeout) 
       if ok then 
        return 
        { new System.IDisposable with 
         member x.Dispose() = 
          semaphore.Release() |> ignore } 
       else 
        return! failwith "couldn't acquire a semaphore" } 

// Gate the number of active web requests 
let webRequestGate = RequestGate(5) 

// Fetch the URL, and post the results to the urlCollector. 
let collectLinks (url:string) = 
    async { // An Async web request with a global gate 
      let! html = 
       async { // Acquire an entry in the webRequestGate. Release 
         // it when 'holder' goes out of scope 
         use! holder = webRequestGate.AcquireAsync() 

         // Wait for the WebResponse 
         let req = WebRequest.Create(url,Timeout=5) 

         use! response = req.AsyncGetResponse() 

         // Get the response stream 
         use reader = new StreamReader(
          response.GetResponseStream()) 

         // Read the response stream 
         return! reader.AsyncReadToEnd() } 

      // Compute the links, synchronously 
      let links = getLinks html 

      // Report, synchronously 
      do printfn "finished reading %s, got %d links" 
        url (List.length links) 

      // We're done 
      return links } 

let urlCollector = 
    MailboxProcessor.Start(fun self -> 
     let rec waitForUrl (visited : Set<string>) = 
      async { if visited.Count < limit then 
         let! url = self.Receive() 
         if not (visited.Contains(url)) then 
          Async.Start 
           (async { let! links = collectLinks url 
             for link in links do 
              do self <-- link }) 
         return! waitForUrl(visited.Add(url)) } 

     waitForUrl(Set.Empty)) 

urlCollector <-- "http://news.google.com" 
// wait for keypress to end program 
System.Console.ReadKey() |> ignore