playing with dns + async composition

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 

let maybe f x = try Some (f x) with _ -> None

module ns = 
  
  open System
  open System.Net
  let child f = Async.StartChild(f, 25200) 

  let maybeAsync f x = async { return (maybe f x) }

  let childAsync f = 
    async { try let! x = f in return! x with _ -> return None }

  let tryAsyncDnsWithChild f = 
    maybeAsync f >> child >> childAsync
    
  (* kinda redundant (parallelism wise) because we do 1 host at a time, look into fixing later*)
  let findHosts f hosts =
    hosts
    |> Array.map (tryAsyncDnsWithChild f)
    |> Async.Parallel
    |> Async.RunSynchronously
    |> Array.filter ((<>) None)
    |> Array.map Option.get
     
  let getFirstEntry a = maybe (Array.get a) 0 |> Option.get
  
  let getHostEntry (h : string) = Dns.GetHostEntry h
  
  let getHostName h = (getHostEntry h).HostName
  let getHostAddr h = (getHostEntry h).AddressList |> getFirstEntry |> string
  
  let g f h = [| findHosts f h |> getFirstEntry |]
  
  let ipsOfDomain = g getHostAddr
  let domainOfIp  = g getHostName 

val maybe : f:('a -> 'b) -> x:'a -> 'b option

Full name: Script.maybe

val f : ('a -> 'b)

val x : 'a

union case Option.Some: Value: 'T -> Option<'T>

union case Option.None: Option<'T>

module ns

from Script

namespace System

namespace System.Net

val child : f:Async<'a> -> Async<Async<'a>>

Full name: Script.ns.child

val f : Async<'a>

Multiple items
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

static member Async.StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>

val maybeAsync : f:('a -> 'b) -> x:'a -> Async<'b option>

Full name: Script.ns.maybeAsync

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val childAsync : f:Async<Async<'a option>> -> Async<'a option>

Full name: Script.ns.childAsync

val f : Async<Async<'a option>>

val x : Async<'a option>

val tryAsyncDnsWithChild : f:('a -> 'b) -> ('a -> Async<'b option>)

Full name: Script.ns.tryAsyncDnsWithChild

val findHosts : f:('a -> 'b) -> hosts:'a [] -> 'b [] (requires equality)

Full name: Script.ns.findHosts

val f : ('a -> 'b) (requires equality)

val hosts : 'a []

type Array =
  member Clone : unit -> obj
  member CopyTo : array:Array * index:int -> unit + 1 overload
  member GetEnumerator : unit -> IEnumerator
  member GetLength : dimension:int -> int
  member GetLongLength : dimension:int -> int64
  member GetLowerBound : dimension:int -> int
  member GetUpperBound : dimension:int -> int
  member GetValue : [<ParamArray>] indices:int[] -> obj + 7 overloads
  member Initialize : unit -> unit
  member IsFixedSize : bool
  ...

Full name: System.Array

val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T

val filter : predicate:('T -> bool) -> array:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.filter

module Option

from Microsoft.FSharp.Core

val get : option:'T option -> 'T

Full name: Microsoft.FSharp.Core.Option.get

val getFirstEntry : a:'a [] -> 'a

Full name: Script.ns.getFirstEntry

val a : 'a []

val get : array:'T [] -> index:int -> 'T

Full name: Microsoft.FSharp.Collections.Array.get

val getHostEntry : h:string -> IPHostEntry

Full name: Script.ns.getHostEntry

val h : string

Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = String

Full name: Microsoft.FSharp.Core.string

type Dns =
  static member BeginGetHostAddresses : hostNameOrAddress:string * requestCallback:AsyncCallback * state:obj -> IAsyncResult
  static member BeginGetHostByName : hostName:string * requestCallback:AsyncCallback * stateObject:obj -> IAsyncResult
  static member BeginGetHostEntry : hostNameOrAddress:string * requestCallback:AsyncCallback * stateObject:obj -> IAsyncResult + 1 overload
  static member BeginResolve : hostName:string * requestCallback:AsyncCallback * stateObject:obj -> IAsyncResult
  static member EndGetHostAddresses : asyncResult:IAsyncResult -> IPAddress[]
  static member EndGetHostByName : asyncResult:IAsyncResult -> IPHostEntry
  static member EndGetHostEntry : asyncResult:IAsyncResult -> IPHostEntry
  static member EndResolve : asyncResult:IAsyncResult -> IPHostEntry
  static member GetHostAddresses : hostNameOrAddress:string -> IPAddress[]
  static member GetHostByAddress : address:string -> IPHostEntry + 1 overload
  ...

Full name: System.Net.Dns

Dns.GetHostEntry(address: IPAddress) : IPHostEntry
Dns.GetHostEntry(hostNameOrAddress: string) : IPHostEntry

val getHostName : h:string -> string

Full name: Script.ns.getHostName

val getHostAddr : h:string -> string

Full name: Script.ns.getHostAddr

val g : f:('a -> 'b) -> h:'a [] -> 'b [] (requires equality)

Full name: Script.ns.g

val h : 'a []

val ipsOfDomain : (string [] -> string [])

Full name: Script.ns.ipsOfDomain

val domainOfIp : (string [] -> string [])

Full name: Script.ns.domainOfIp