1: open System
 2: open System.Collections.Generic
 3: 
 4: type CircularBuffer<'T> (bufferSize:int) =
 5:     let buffer = Array.zeroCreate<'T> bufferSize
 6:     let mutable index = 0
 7:     let mutable total = 0
 8:     member this.Add value =
 9:         if bufferSize > 0 then
10:             buffer.[index] <- value
11:             index <- (index + 1) % bufferSize
12:             total <- min (total + 1) bufferSize
13:     member this.Iter f =     
14:         let start = if total = bufferSize then index else 0
15:         for i = 0 to total - 1 do 
16:             buffer.[(start + i) % bufferSize] |> f                 
17: 
18: type message<'T> =
19:     | Add of IObserver<'T>
20:     | Remove of IObserver<'T>
21:     | Next of 'T
22:     | Completed
23:     | Error of exn
24: 
25: let startAgent (bufferSize:int) =
26:     let subscribers = LinkedList<_>()
27:     let buffer = CircularBuffer bufferSize               
28:     MailboxProcessor.Start(fun inbox ->
29:         let rec loop () = async {
30:             let! message = inbox.Receive()
31:             match message with
32:             | Add observer ->                    
33:                 subscribers.AddLast observer |> ignore
34:                 buffer.Iter observer.OnNext
35:                 return! loop ()
36:             | Remove observer ->
37:                 subscribers.Remove observer |> ignore
38:                 return! loop ()
39:             | Next value ->                                       
40:                 for subscriber in subscribers do
41:                     subscriber.OnNext value
42:                 buffer.Add value
43:                 return! loop () 
44:             | Error e ->
45:                 for subscriber in subscribers do
46:                     subscriber.OnError e
47:             | Completed ->
48:                 for subscriber in subscribers do
49:                     subscriber.OnCompleted ()
50:         }
51:         loop ()
52:     )
53: 
54: type ReplaySubject<'T> (bufferSize:int) =
55:     let bufferSize = max 0 bufferSize
56:     let agent = startAgent bufferSize    
57:     let subscribe observer =
58:         observer |> Add |> agent.Post
59:         { new System.IDisposable with
60:             member this.Dispose () =
61:                 observer |> Remove |> agent.Post
62:         }
63:     member this.Next value = Next value |> agent.Post
64:     member this.Error error = Error error |> agent.Post
65:     member this.Completed () = Completed |> agent.Post    
66:     interface System.IObserver<'T> with
67:         member this.OnNext value = Next value |> agent.Post
68:         member this.OnError error = Error error |> agent.Post
69:         member this.OnCompleted () = Completed |> agent.Post
70:     member this.Subscribe(observer:System.IObserver<'T>) =
71:         subscribe observer
72:     interface System.IObservable<'T> with
73:         member this.Subscribe observer = subscribe observer                   
74: and Subject<'T>() = inherit ReplaySubject<'T>(0)
75: 
76: do  let subject = ReplaySubject(3)            
77:     use d = subject.Subscribe(fun (x:int) -> System.Console.WriteLine x)
78:     subject.Next(10)
79:     subject.Next(11)
80:     use d = subject.Subscribe(fun (x:int) -> System.Console.WriteLine x)
81:     System.Console.ReadLine() |> ignore

namespace System

namespace System.Collections

namespace System.Collections.Generic

type CircularBuffer<'T> =
  class
    new : bufferSize:int -> CircularBuffer<'T>
    member Add : value:'T -> unit
    member Iter : f:('T -> unit) -> unit
  end

Full name: Snippet.CircularBuffer<_>

val bufferSize : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

Multiple items
val int : 'T -> int (requires member op_Explicit)

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

--------------------

type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

  type: int<'Measure>
  implements: IComparable
  implements: IConvertible
  implements: IFormattable
  implements: IComparable<int<'Measure>>
  implements: IEquatable<int<'Measure>>
  inherits: ValueType


--------------------

type int = int32

Full name: Microsoft.FSharp.Core.int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val buffer : 'T []

  type: 'T []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: IList<'T>
  implements: ICollection<'T>
  implements: seq<'T>
  implements: Collections.IEnumerable
  inherits: Array

type Array =
  class
    member Clone : unit -> obj
    member CopyTo : System.Array * int -> unit
    member CopyTo : System.Array * int64 -> unit
    member GetEnumerator : unit -> System.Collections.IEnumerator
    member GetLength : int -> int
    member GetLongLength : int -> int64
    member GetLowerBound : int -> int
    member GetUpperBound : int -> int
    member GetValue : int [] -> obj
    member GetValue : int -> obj
    member GetValue : int64 -> obj
    member GetValue : int64 [] -> obj
    member GetValue : int * int -> obj
    member GetValue : int64 * int64 -> obj
    member GetValue : int * int * int -> obj
    member GetValue : int64 * int64 * int64 -> obj
    member Initialize : unit -> unit
    member IsFixedSize : bool
    member IsReadOnly : bool
    member IsSynchronized : bool
    member Length : int
    member LongLength : int64
    member Rank : int
    member SetValue : obj * int -> unit
    member SetValue : obj * int [] -> unit
    member SetValue : obj * int64 -> unit
    member SetValue : obj * int64 [] -> unit
    member SetValue : obj * int * int -> unit
    member SetValue : obj * int64 * int64 -> unit
    member SetValue : obj * int * int * int -> unit
    member SetValue : obj * int64 * int64 * int64 -> unit
    member SyncRoot : obj
    static member AsReadOnly<'T> : 'T [] -> System.Collections.ObjectModel.ReadOnlyCollection<'T>
    static member BinarySearch : System.Array * obj -> int
    static member BinarySearch<'T> : 'T [] * 'T -> int
    static member BinarySearch : System.Array * obj * System.Collections.IComparer -> int
    static member BinarySearch<'T> : 'T [] * 'T * System.Collections.Generic.IComparer<'T> -> int
    static member BinarySearch : System.Array * int * int * obj -> int
    static member BinarySearch<'T> : 'T [] * int * int * 'T -> int
    static member BinarySearch : System.Array * int * int * obj * System.Collections.IComparer -> int
    static member BinarySearch<'T> : 'T [] * int * int * 'T * System.Collections.Generic.IComparer<'T> -> int
    static member Clear : System.Array * int * int -> unit
    static member ConstrainedCopy : System.Array * int * System.Array * int * int -> unit
    static member ConvertAll<'TInput,'TOutput> : 'TInput [] * System.Converter<'TInput,'TOutput> -> 'TOutput []
    static member Copy : System.Array * System.Array * int -> unit
    static member Copy : System.Array * System.Array * int64 -> unit
    static member Copy : System.Array * int * System.Array * int * int -> unit
    static member Copy : System.Array * int64 * System.Array * int64 * int64 -> unit
    static member CreateInstance : System.Type * int -> System.Array
    static member CreateInstance : System.Type * int [] -> System.Array
    static member CreateInstance : System.Type * int64 [] -> System.Array
    static member CreateInstance : System.Type * int * int -> System.Array
    static member CreateInstance : System.Type * int [] * int [] -> System.Array
    static member CreateInstance : System.Type * int * int * int -> System.Array
    static member Exists<'T> : 'T [] * System.Predicate<'T> -> bool
    static member Find<'T> : 'T [] * System.Predicate<'T> -> 'T
    static member FindAll<'T> : 'T [] * System.Predicate<'T> -> 'T []
    static member FindIndex<'T> : 'T [] * System.Predicate<'T> -> int
    static member FindIndex<'T> : 'T [] * int * System.Predicate<'T> -> int
    static member FindIndex<'T> : 'T [] * int * int * System.Predicate<'T> -> int
    static member FindLast<'T> : 'T [] * System.Predicate<'T> -> 'T
    static member FindLastIndex<'T> : 'T [] * System.Predicate<'T> -> int
    static member FindLastIndex<'T> : 'T [] * int * System.Predicate<'T> -> int
    static member FindLastIndex<'T> : 'T [] * int * int * System.Predicate<'T> -> int
    static member ForEach<'T> : 'T [] * System.Action<'T> -> unit
    static member IndexOf : System.Array * obj -> int
    static member IndexOf<'T> : 'T [] * 'T -> int
    static member IndexOf : System.Array * obj * int -> int
    static member IndexOf<'T> : 'T [] * 'T * int -> int
    static member IndexOf : System.Array * obj * int * int -> int
    static member IndexOf<'T> : 'T [] * 'T * int * int -> int
    static member LastIndexOf : System.Array * obj -> int
    static member LastIndexOf<'T> : 'T [] * 'T -> int
    static member LastIndexOf : System.Array * obj * int -> int
    static member LastIndexOf<'T> : 'T [] * 'T * int -> int
    static member LastIndexOf : System.Array * obj * int * int -> int
    static member LastIndexOf<'T> : 'T [] * 'T * int * int -> int
    static member Resize<'T> : 'T [] * int -> unit
    static member Reverse : System.Array -> unit
    static member Reverse : System.Array * int * int -> unit
    static member Sort : System.Array -> unit
    static member Sort<'T> : 'T [] -> unit
    static member Sort : System.Array * System.Array -> unit
    static member Sort : System.Array * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] -> unit
    static member Sort<'T> : 'T [] * System.Collections.Generic.IComparer<'T> -> unit
    static member Sort<'T> : 'T [] * System.Comparison<'T> -> unit
    static member Sort : System.Array * int * int -> unit
    static member Sort : System.Array * System.Array * System.Collections.IComparer -> unit
    static member Sort<'T> : 'T [] * int * int -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * System.Collections.Generic.IComparer<'TKey> -> unit
    static member Sort : System.Array * System.Array * int * int -> unit
    static member Sort : System.Array * int * int * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * int * int -> unit
    static member Sort<'T> : 'T [] * int * int * System.Collections.Generic.IComparer<'T> -> unit
    static member Sort : System.Array * System.Array * int * int * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * int * int * System.Collections.Generic.IComparer<'TKey> -> unit
    static member TrueForAll<'T> : 'T [] * System.Predicate<'T> -> bool
  end

Full name: System.Array

  type: Array
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IEnumerable
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable

val zeroCreate : int -> 'T []

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

val mutable index : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val mutable total : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val this : CircularBuffer<'T>

member CircularBuffer.Add : value:'T -> unit

Full name: Snippet.CircularBuffer`1.Add

val value : 'T

val min : 'T -> 'T -> 'T (requires comparison)

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

member CircularBuffer.Iter : f:('T -> unit) -> unit

Full name: Snippet.CircularBuffer`1.Iter

val f : ('T -> unit)

val start : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val i : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

type message<'T> =
  | Add of IObserver<'T>
  | Remove of IObserver<'T>
  | Next of 'T
  | Completed
  | Error of exn

Full name: Snippet.message<_>

  type: message<'T>
  implements: IEquatable<message<'T>>
  implements: Collections.IStructuralEquatable

union case message.Add: IObserver<'T> -> message<'T>

Multiple items
type IObserver<'T> =
  interface
    member OnCompleted : unit -> unit
    member OnError : System.Exception -> unit
    member OnNext : 'T -> unit
  end

Full name: System.IObserver<_>

--------------------

IObserver

union case message.Remove: IObserver<'T> -> message<'T>

union case message.Next: 'T -> message<'T>

union case message.Completed: message<'T>

union case message.Error: exn -> message<'T>

type exn = Exception

Full name: Microsoft.FSharp.Core.exn

  type: exn
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.InteropServices._Exception

val startAgent : int -> MailboxProcessor<message<'a>>

Full name: Snippet.startAgent

val subscribers : LinkedList<IObserver<'a>>

  type: LinkedList<IObserver<'a>>
  implements: ICollection<IObserver<'a>>
  implements: seq<IObserver<'a>>
  implements: Collections.ICollection
  implements: Collections.IEnumerable
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.Serialization.IDeserializationCallback

type LinkedList<'T> =
  class
    new : unit -> System.Collections.Generic.LinkedList<'T>
    new : System.Collections.Generic.IEnumerable<'T> -> System.Collections.Generic.LinkedList<'T>
    member AddAfter : System.Collections.Generic.LinkedListNode<'T> * 'T -> System.Collections.Generic.LinkedListNode<'T>
    member AddAfter : System.Collections.Generic.LinkedListNode<'T> * System.Collections.Generic.LinkedListNode<'T> -> unit
    member AddBefore : System.Collections.Generic.LinkedListNode<'T> * 'T -> System.Collections.Generic.LinkedListNode<'T>
    member AddBefore : System.Collections.Generic.LinkedListNode<'T> * System.Collections.Generic.LinkedListNode<'T> -> unit
    member AddFirst : 'T -> System.Collections.Generic.LinkedListNode<'T>
    member AddFirst : System.Collections.Generic.LinkedListNode<'T> -> unit
    member AddLast : 'T -> System.Collections.Generic.LinkedListNode<'T>
    member AddLast : System.Collections.Generic.LinkedListNode<'T> -> unit
    member Clear : unit -> unit
    member Contains : 'T -> bool
    member CopyTo : 'T [] * int -> unit
    member Count : int
    member Find : 'T -> System.Collections.Generic.LinkedListNode<'T>
    member FindLast : 'T -> System.Collections.Generic.LinkedListNode<'T>
    member First : System.Collections.Generic.LinkedListNode<'T>
    member GetEnumerator : unit -> Enumerator<'T>
    member GetObjectData : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> unit
    member Last : System.Collections.Generic.LinkedListNode<'T>
    member OnDeserialization : obj -> unit
    member Remove : 'T -> bool
    member Remove : System.Collections.Generic.LinkedListNode<'T> -> unit
    member RemoveFirst : unit -> unit
    member RemoveLast : unit -> unit
    type Enumerator =
      struct
        member Current : 'T
        member Dispose : unit -> unit
        member MoveNext : unit -> bool
      end
  end

Full name: System.Collections.Generic.LinkedList<_>

  type: LinkedList<'T>
  implements: ICollection<'T>
  implements: seq<'T>
  implements: Collections.ICollection
  implements: Collections.IEnumerable
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.Serialization.IDeserializationCallback

val buffer : CircularBuffer<'a>

type MailboxProcessor<'Msg> =
  class
    interface IDisposable
    new : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
    member Post : message:'Msg -> unit
    member PostAndAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply>
    member PostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply
    member PostAndTryAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply option>
    member Receive : ?timeout:int -> Async<'Msg>
    member Scan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T>
    member Start : unit -> unit
    member TryPostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply option
    member TryReceive : ?timeout:int -> Async<'Msg option>
    member TryScan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T option>
    member add_Error : Handler<Exception> -> unit
    member CurrentQueueLength : int
    member DefaultTimeout : int
    member Error : IEvent<Exception>
    member remove_Error : Handler<Exception> -> unit
    member DefaultTimeout : int with set
    static member Start : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
  end

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

  type: MailboxProcessor<'Msg>
  implements: IDisposable

static member MailboxProcessor.Start : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>

val inbox : MailboxProcessor<message<'a>>

  type: MailboxProcessor<message<'a>>
  implements: IDisposable

val loop : (unit -> Async<unit>)

val async : AsyncBuilder

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

Multiple items
val message : message<'a>

  type: message<'a>
  implements: IEquatable<message<'a>>
  implements: Collections.IStructuralEquatable


--------------------

type message<'T> =
  | Add of IObserver<'T>
  | Remove of IObserver<'T>
  | Next of 'T
  | Completed
  | Error of exn

Full name: Snippet.message<_>

  type: message<'T>
  implements: IEquatable<message<'T>>
  implements: Collections.IStructuralEquatable

member MailboxProcessor.Receive : ?timeout:int -> Async<'Msg>

val observer : IObserver<'a>

Multiple overloads
LinkedList.AddLast(node: LinkedListNode<IObserver<'a>>) : unit
LinkedList.AddLast(value: IObserver<'a>) : LinkedListNode<IObserver<'a>>

val ignore : 'T -> unit

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

member CircularBuffer.Iter : f:('T -> unit) -> unit

IObserver.OnNext(value: 'a) : unit

Multiple overloads
LinkedList.Remove(node: LinkedListNode<IObserver<'a>>) : unit
LinkedList.Remove(value: IObserver<'a>) : bool

val value : 'a

val subscriber : IObserver<'a>

member CircularBuffer.Add : value:'T -> unit

val e : exn

  type: exn
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.InteropServices._Exception

type ReplaySubject<'T> =
  class
    interface IObservable<'T>
    interface IObserver<'T>
    new : bufferSize:int -> ReplaySubject<'T>
    member Completed : unit -> unit
    member Error : error:exn -> unit
    member Next : value:'T -> unit
    member Subscribe : observer:IObserver<'T> -> IDisposable
  end

Full name: Snippet.ReplaySubject<_>

  type: ReplaySubject<'T>
  implements: IObservable<'T>
  implements: IObserver<'T>

val max : 'T -> 'T -> 'T (requires comparison)

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

val agent : MailboxProcessor<message<'T>>

  type: MailboxProcessor<message<'T>>
  implements: IDisposable

val subscribe : (IObserver<'T> -> IDisposable)

val observer : IObserver<'T>

member MailboxProcessor.Post : message:'Msg -> unit

Multiple items
type IDisposable =
  interface
    member Dispose : unit -> unit
  end

Full name: System.IDisposable

--------------------

IDisposable

val this : IDisposable

IDisposable.Dispose() : unit

val this : ReplaySubject<'T>

  type: ReplaySubject<'T>
  implements: IObservable<'T>
  implements: IObserver<'T>

member ReplaySubject.Next : value:'T -> unit

Full name: Snippet.ReplaySubject`1.Next

member ReplaySubject.Error : error:exn -> unit

Full name: Snippet.ReplaySubject`1.Error

val error : exn

  type: exn
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.InteropServices._Exception

member ReplaySubject.Completed : unit -> unit

Full name: Snippet.ReplaySubject`1.Completed

override ReplaySubject.OnNext : value:'T -> unit

Full name: Snippet.ReplaySubject`1.OnNext

override ReplaySubject.OnError : error:exn -> unit

Full name: Snippet.ReplaySubject`1.OnError

override ReplaySubject.OnCompleted : unit -> unit

Full name: Snippet.ReplaySubject`1.OnCompleted

member ReplaySubject.Subscribe : observer:IObserver<'T> -> IDisposable

Full name: Snippet.ReplaySubject`1.Subscribe

Multiple items
type IObservable<'T> =
  interface
    member Subscribe : System.IObserver<'T> -> System.IDisposable
  end

Full name: System.IObservable<_>

--------------------

IObservable

override ReplaySubject.Subscribe : observer:IObserver<'T> -> IDisposable

Full name: Snippet.ReplaySubject`1.Subscribe

type Subject<'T> =
  class
    inherit ReplaySubject<'T>
    new : unit -> Subject<'T>
  end

Full name: Snippet.Subject<_>

  type: Subject<'T>
  implements: IObservable<'T>
  implements: IObserver<'T>
  inherits: ReplaySubject<'T>

val subject : ReplaySubject<int>

  type: ReplaySubject<int>
  implements: IObservable<int>
  implements: IObserver<int>

val d : IDisposable

Multiple overloads
member IObservable.Subscribe : callback:('T -> unit) -> IDisposable
member ReplaySubject.Subscribe : observer:IObserver<'T> -> IDisposable

val x : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

type Console =
  class
    static member BackgroundColor : System.ConsoleColor with get, set
    static member Beep : unit -> unit
    static member Beep : int * int -> unit
    static member BufferHeight : int with get, set
    static member BufferWidth : int with get, set
    static member CapsLock : bool
    static member Clear : unit -> unit
    static member CursorLeft : int with get, set
    static member CursorSize : int with get, set
    static member CursorTop : int with get, set
    static member CursorVisible : bool with get, set
    static member Error : System.IO.TextWriter
    static member ForegroundColor : System.ConsoleColor with get, set
    static member In : System.IO.TextReader
    static member InputEncoding : System.Text.Encoding with get, set
    static member KeyAvailable : bool
    static member LargestWindowHeight : int
    static member LargestWindowWidth : int
    static member MoveBufferArea : int * int * int * int * int * int -> unit
    static member MoveBufferArea : int * int * int * int * int * int * char * System.ConsoleColor * System.ConsoleColor -> unit
    static member NumberLock : bool
    static member OpenStandardError : unit -> System.IO.Stream
    static member OpenStandardError : int -> System.IO.Stream
    static member OpenStandardInput : unit -> System.IO.Stream
    static member OpenStandardInput : int -> System.IO.Stream
    static member OpenStandardOutput : unit -> System.IO.Stream
    static member OpenStandardOutput : int -> System.IO.Stream
    static member Out : System.IO.TextWriter
    static member OutputEncoding : System.Text.Encoding with get, set
    static member Read : unit -> int
    static member ReadKey : unit -> System.ConsoleKeyInfo
    static member ReadKey : bool -> System.ConsoleKeyInfo
    static member ReadLine : unit -> string
    static member ResetColor : unit -> unit
    static member SetBufferSize : int * int -> unit
    static member SetCursorPosition : int * int -> unit
    static member SetError : System.IO.TextWriter -> unit
    static member SetIn : System.IO.TextReader -> unit
    static member SetOut : System.IO.TextWriter -> unit
    static member SetWindowPosition : int * int -> unit
    static member SetWindowSize : int * int -> unit
    static member Title : string with get, set
    static member TreatControlCAsInput : bool with get, set
    static member WindowHeight : int with get, set
    static member WindowLeft : int with get, set
    static member WindowTop : int with get, set
    static member WindowWidth : int with get, set
    static member Write : bool -> unit
    static member Write : char -> unit
    static member Write : char [] -> unit
    static member Write : float -> unit
    static member Write : decimal -> unit
    static member Write : float32 -> unit
    static member Write : int -> unit
    static member Write : uint32 -> unit
    static member Write : int64 -> unit
    static member Write : uint64 -> unit
    static member Write : obj -> unit
    static member Write : string -> unit
    static member Write : string * obj -> unit
    static member Write : string * obj [] -> unit
    static member Write : string * obj * obj -> unit
    static member Write : char [] * int * int -> unit
    static member Write : string * obj * obj * obj -> unit
    static member Write : string * obj * obj * obj * obj -> unit
    static member WriteLine : unit -> unit
    static member WriteLine : bool -> unit
    static member WriteLine : char -> unit
    static member WriteLine : char [] -> unit
    static member WriteLine : decimal -> unit
    static member WriteLine : float -> unit
    static member WriteLine : float32 -> unit
    static member WriteLine : int -> unit
    static member WriteLine : uint32 -> unit
    static member WriteLine : int64 -> unit
    static member WriteLine : uint64 -> unit
    static member WriteLine : obj -> unit
    static member WriteLine : string -> unit
    static member WriteLine : string * obj -> unit
    static member WriteLine : string * obj [] -> unit
    static member WriteLine : char [] * int * int -> unit
    static member WriteLine : string * obj * obj -> unit
    static member WriteLine : string * obj * obj * obj -> unit
    static member WriteLine : string * obj * obj * obj * obj -> unit
  end

Full name: System.Console

Multiple overloads
Console.WriteLine() : unit
Console.WriteLine(value: string) : unit
Console.WriteLine(value: obj) : unit
Console.WriteLine(value: uint64) : unit
Console.WriteLine(value: int64) : unit
Console.WriteLine(value: uint32) : unit
Console.WriteLine(value: int) : unit
Console.WriteLine(value: float32) : unit
Console.WriteLine(value: float) : unit
Console.WriteLine(value: decimal) : unit
   (+9 other overloads)

member ReplaySubject.Next : value:'T -> unit

Console.ReadLine() : string