A simple functional F# wrapper for EasyNetQ

Question

This is my first attempt at creating a small module to wrap the .NET library EasyNetQ in F# to make it more functional.

I am pretty new to F# and I would like to get feedbacks on everything: types, naming conventions, functional thinking, etc.

RabbitMQ.fs:

module RabbitMQ
 open EasyNetQ
 open System
 type BusConnection = {
 Address: string
 Port: uint16
 Username: string
 Password: string
 }
 type NamingConventions = {
 RetrieveQueueName: Type -> string -> string
 RetrieveExchangeName: Type -> string
 RetrieveErrorQueueName: MessageReceivedInfo -> string
 RetrieveErrorExchangeName: MessageReceivedInfo -> string
 }
 type Subscription<'T> = {
 Id: string
 OnMessageReceived: 'T -> unit
 }
 let private buildConnectionString (busConnection: BusConnection) =
 sprintf "host=%s:%d;username=%s;password=%s"
 busConnection.Address
 busConnection.Port
 busConnection.Username
 busConnection.Password
 let createBus (connection: BusConnection) =
 let connectionString = buildConnectionString connection
 RabbitHutch.CreateBus(connectionString)
 let publishAsync<'T> (bus: IBus) (message: 'T) = bus.PubSub.PublishAsync<'T>(message)
 |> Async.AwaitTask
 let subscribeAsync<'T> (bus: IBus) (subscription: Subscription<'T>) = bus.PubSub.SubscribeAsync<'T>(subscription.Id, subscription.OnMessageReceived).AsTask()
 |> Async.AwaitTask
 let setNamingConventions (bus: IBus) (namingConventions: NamingConventions) =
 bus.Advanced.Conventions.QueueNamingConvention <- new QueueNameConvention(namingConventions.RetrieveQueueName)
 bus.Advanced.Conventions.ExchangeNamingConvention <- new ExchangeNameConvention(namingConventions.RetrieveExchangeName)
 bus.Advanced.Conventions.ErrorQueueNamingConvention <- new ErrorQueueNameConvention(namingConventions.RetrieveErrorQueueName)
 bus.Advanced.Conventions.ErrorExchangeNamingConvention <- new ErrorExchangeNameConvention(namingConventions.RetrieveErrorExchangeName)

Program.fs:

open RabbitMQ
type Message = {
 Text: string
}
[<EntryPoint>]
let main argv =
 let busConnection = {
 Address = "localhost"
 Port = 5672 |> uint16
 Username = "guest"
 Password = "guest"
 }
 let namingConventions = {
 RetrieveQueueName = fun messageType subscriptionId -> "Queue: " + (messageType.FullName + subscriptionId)
 RetrieveExchangeName = fun messageType -> "Exchange: " + messageType.FullName
 RetrieveErrorQueueName = fun messageReceivedInfo -> messageReceivedInfo.Queue + " - Error"
 RetrieveErrorExchangeName = fun messageReceivedInfo -> messageReceivedInfo.Exchange + " - Error"
 }
 use bus = createBus busConnection
 setNamingConventions bus namingConventions
 let subscription = {
 Id = "subscription_id"
 OnMessageReceived = fun (message: Message) -> printfn "%A" message
 }
 async {
 let! result = subscribeAsync<Message> bus subscription
 do! publishAsync<Message> bus {Text = "1"}
 do! publishAsync<Message> bus {Text = "2"}
 do! publishAsync<Message> bus {Text = "3"}
 } |> Async.RunSynchronously
 Console.waitPressKey
 0

Console.fs

module Console
 open System
 let waitPressKey = Console.ReadKey() |> ignore