Checkout form

Let's take a deep breath and roll to the last significant feature in our application!

Again, checkout will be based on a form:

Form.fs

  45: 
  46: 
  47: 
  48: 
  49: 
  50: 
type Checkout = { FirstName : string LastName : string Address : string PromoCode : string option }

Note that, while first three fields are mandatory, the last one "PromoCode" is optional (it's type is string option).

Following is the view for the checkout form:

View.fs

 351: 
 352: 
 353: 
 354: 
 355: 
 356: 
 357: 
 358: 
 359: 
 360: 
 361: 
 362: 
 363: 
 364: 
 365: 
 366: 
 367: 
 368: 
 369: 
 370: 
 371: 
let checkout = [ h2 "Address And Payment" renderForm { Form = Form.checkout Fieldsets = [ { Legend = "Shipping Information" Fields = [ { Label = "First Name" Html = formInput (fun f -> <@ f.FirstName @>) [] } { Label = "Last Name" Html = formInput (fun f -> <@ f.LastName @>) [] } { Label = "Address" Html = formInput (fun f -> <@ f.Address @>) [] } ] } { Legend = "Payment" Fields = [ { Label = "Promo Code" Html = formInput (fun f -> <@ f.PromoCode @>) [] } ] } ] SubmitText = "Submit Order" } ]

Note that there are 2 fieldsets here, whereas before we used only 1. Thanks to multiple fieldsets we can group fields that have something in common.

Now let's add a route for checkout (Path.Cart):

Path.fs

  27: 
  28: 
  29: 
  30: 
  31: 
module Cart = let overview = "/cart" let addAlbum : IntPath = "/cart/add/%d" let removeAlbum : IntPath = "/cart/remove/%d" let checkout = "/cart/checkout"

a navigation button in View.nonEmptyCart :

View.fs

 277: 
 278: 
 279: 
 280: 
 281: 
 282: 
let nonEmptyCart (carts : Db.CartDetails list) = [ h2 "Review your cart:" p ["class", "button"] [ a Path.Cart.checkout [] [Text "Checkout >>"] ] div ["id", "update-message"] [Text " "]

and GET handler for checkout in App module:

App.fs

 276: 
 277: 
 278: 
 279: 
 280: 
 281: 
 282: 
let checkout = session (function | NoSession | CartIdOnly _ -> never | UserLoggedOn {Username = username } -> choose [ GET >=> (View.checkout |> html) ])

App.fs

 303: 
path Path.Cart.checkout >=> loggedOn checkout

Remarks:

  • checkout can only be invoked if user is logged on. If there is NoSession or CartIdOnly we don't want to let anyone in.
  • additionally we decorated the checkout WebPart with loggedOn in the routing code. This ensures to redirect user to logon form if necessary.
    Multiple items
    namespace FSharp

    --------------------
    namespace Microsoft.FSharp
    Multiple items
    namespace FSharp.Data

    --------------------
    namespace Microsoft.FSharp.Data
    namespace FSharp.Data.Sql
    Multiple items
    type LiteralAttribute =
    inherit Attribute
    new : unit -> LiteralAttribute

    Full name: Microsoft.FSharp.Core.LiteralAttribute

    --------------------
    new : unit -> LiteralAttribute
    val ConnectionString : string

    Full name: SuaveMusicStore.Db.ConnectionString
    type Sql = SqlDataProvider<...>

    Full name: SuaveMusicStore.Db.Sql
    type SqlDataProvider

    Full name: FSharp.Data.Sql.SqlDataProvider


    <summary>Typed representation of a database</summary>
    <param name='ConnectionString'>The connection string for the SQL database</param>
    <param name='ConnectionStringName'>The connection string name to select from a configuration file</param>
    <param name='DatabaseVendor'> The target database vendor</param>
    <param name='IndividualsAmount'>The amount of sample entities to project into the type system for each SQL entity type. Default 1000.</param>
    <param name='UseOptionTypes'>If true, F# option types will be used in place of nullable database columns. If false, you will always receive the default value of the column's type even if it is null in the database.</param>
    <param name='ResolutionPath'>The location to look for dynamically loaded assemblies containing database vendor specific connections and custom types.</param>
    <param name='Owner'>The owner of the schema for this provider to resolve (Oracle Only)</param>
    <param name='CaseSensitivityChange'>Should we do ToUpper or ToLower when generating table names?</param>
    <param name='TableNames'>Comma separated table names list to limit a number of tables in big instances. The names can have '%' sign to handle it as in the 'LIKE' query (Oracle and MSSQL Only)</param>
    <param name='OdbcQuote'>Odbc quote characters: Quote characters for the table and column names: `alias`, [alias]</param>
    <param name='SQLiteLibrary'>Use System.Data.SQLite or Mono.Data.SQLite or select automatically (SQLite only)</param>
    namespace FSharp.Data.Sql.Common
    type DatabaseProviderTypes =
    | MSSQLSERVER = 0
    | SQLITE = 1
    | POSTGRESQL = 2
    | MYSQL = 3
    | ORACLE = 4
    | MSACCESS = 5
    | ODBC = 6
    | FIREBIRD = 7

    Full name: FSharp.Data.Sql.Common.DatabaseProviderTypes
    Common.DatabaseProviderTypes.POSTGRESQL: Common.DatabaseProviderTypes = 2
    type CaseSensitivityChange =
    | ORIGINAL = 0
    | TOUPPER = 1
    | TOLOWER = 2

    Full name: FSharp.Data.Sql.Common.CaseSensitivityChange
    Common.CaseSensitivityChange.ORIGINAL: Common.CaseSensitivityChange = 0
    type DbContext = SqlDataProvider<...>.dataContext

    Full name: SuaveMusicStore.Db.DbContext
    type dataContext =
    member ClearUpdates : unit -> List<SqlEntity>
    member CreateConnection : unit -> IDbConnection
    member GetUpdates : unit -> List<SqlEntity>
    member Public : publicSchema
    member SubmitUpdates : unit -> Unit
    member SubmitUpdatesAsync : unit -> Async<Unit>
    nested type public.albumdetails.Individuals
    nested type public.albumdetailsEntity
    nested type public.albums.Individuals
    nested type public.albumsEntity
    ...

    Full name: FSharp.Data.Sql.SqlDataProvider,DatabaseVendor="2",ConnectionString="Server=192.168.99.100;Database=suavemusicstore;User Id=suave;Password=1234;",CaseSensitivityChange="0".dataContext
    type Album = SqlDataProvider<...>.dataContext.public.albumsEntity

    Full name: SuaveMusicStore.Db.Album
    type Genre = SqlDataProvider<...>.dataContext.public.genresEntity

    Full name: SuaveMusicStore.Db.Genre
    type AlbumDetails = SqlDataProvider<...>.dataContext.public.albumdetailsEntity

    Full name: SuaveMusicStore.Db.AlbumDetails
    type Artist = SqlDataProvider<...>.dataContext.public.artistsEntity

    Full name: SuaveMusicStore.Db.Artist
    type User = SqlDataProvider<...>.dataContext.public.usersEntity

    Full name: SuaveMusicStore.Db.User
    type CartDetails = SqlDataProvider<...>.dataContext.public.cartdetailsEntity

    Full name: SuaveMusicStore.Db.CartDetails
    type Cart = SqlDataProvider<...>.dataContext.public.cartsEntity

    Full name: SuaveMusicStore.Db.Cart
    val getContext : unit -> SqlDataProvider<...>.dataContext

    Full name: SuaveMusicStore.Db.getContext
    SqlDataProvider<...>.GetDataContext() : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider using the static parameters</summary>

    SqlDataProvider<...>.GetDataContext(transactionOptions: Transactions.TransactionOptions) : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider</summary>
    <param name='transactionOptions'>TransactionOptions for the transaction created on SubmitChanges.</param>

    SqlDataProvider<...>.GetDataContext(connectionString: string) : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider</summary>
    <param name='connectionString'>The database connection string</param>

    SqlDataProvider<...>.GetDataContext(connectionString: string, transactionOptions: Transactions.TransactionOptions) : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider</summary>
    <param name='connectionString'>The database connection string</param>
    <param name='transactionOptions'>TransactionOptions for the transaction created on SubmitChanges.</param>

    SqlDataProvider<...>.GetDataContext(connectionString: string, resolutionPath: string) : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider</summary>
    <param name='connectionString'>The database connection string</param>
    <param name='resolutionPath'>The location to look for dynamically loaded assemblies containing database vendor specific connections and custom types</param>

    SqlDataProvider<...>.GetDataContext(connectionString: string, resolutionPath: string, transactionOptions: Transactions.TransactionOptions) : SqlDataProvider<...>.dataContext


    <summary>Returns an instance of the SQL Provider</summary>
    <param name='connectionString'>The database connection string</param>
    <param name='resolutionPath'>The location to look for dynamically loaded assemblies containing database vendor specific connections and custom types</param>
    <param name='transactionOptions'>TransactionOptions for the transaction created on SubmitChanges.</param>
    val getGenres : ctx:DbContext -> Genre list

    Full name: SuaveMusicStore.Db.getGenres
    val ctx : DbContext
    type 'T list = List<'T>

    Full name: Microsoft.FSharp.Collections.list<_>
    property SqlDataProvider<...>.dataContext.Public: SqlDataProvider<...>.dataContext.publicSchema
    property SqlDataProvider<...>.dataContext.publicSchema.Genres: SqlDataProvider<...>.dataContext.publicSchema.public.genres


    <summary> The base table genres belonging to schema public</summary>
    Multiple items
    module Seq

    from FSharp.Data.Sql

    --------------------
    module Seq

    from Microsoft.FSharp.Collections
    val toList : source:seq<'T> -> 'T list

    Full name: Microsoft.FSharp.Collections.Seq.toList
    val getAlbumsForGenre : genreName:string -> ctx:DbContext -> Album list

    Full name: SuaveMusicStore.Db.getAlbumsForGenre
    val genreName : string
    val query : Linq.QueryBuilder

    Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.query
    val album : SqlDataProvider<...>.dataContext.public.albumsEntity
    property SqlDataProvider<...>.dataContext.publicSchema.Albums: SqlDataProvider<...>.dataContext.publicSchema.public.albums


    <summary> The base table albums belonging to schema public</summary>
    custom operation: join var in collection on (outerKey = innerKey). Note that parentheses are required after 'on'

    Calls Linq.QueryBuilder.Join
    val genre : SqlDataProvider<...>.dataContext.public.genresEntity
    property SqlDataProvider<...>.dataContext.public.genresEntity.Genreid: int


    <summary> integer</summary>
    custom operation: where (bool)

    Calls Linq.QueryBuilder.Where
    property SqlDataProvider<...>.dataContext.public.genresEntity.Name: string


    <summary> character varying(120)</summary>
    custom operation: select ('Result)

    Calls Linq.QueryBuilder.Select
    val getAlbumDetails : id:int -> ctx:DbContext -> AlbumDetails option

    Full name: SuaveMusicStore.Db.getAlbumDetails
    val id : int
    type 'T option = Option<'T>

    Full name: Microsoft.FSharp.Core.option<_>
    val album : SqlDataProvider<...>.dataContext.public.albumdetailsEntity
    property SqlDataProvider<...>.dataContext.publicSchema.Albumdetails: SqlDataProvider<...>.dataContext.publicSchema.public.albumdetails


    <summary> The view albumdetails belonging to schema public</summary>
    property SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Albumid: int


    <summary> integer</summary>
    val tryHead : source:seq<'T> -> 'T option

    Full name: Microsoft.FSharp.Collections.Seq.tryHead
    val getAlbumsDetails : ctx:DbContext -> AlbumDetails list

    Full name: SuaveMusicStore.Db.getAlbumsDetails
    Multiple items
    module List

    from FSharp.Data.Sql

    --------------------
    module List

    from Microsoft.FSharp.Collections

    --------------------
    type List<'T> =
    | ( [] )
    | ( :: ) of Head: 'T * Tail: 'T list
    interface IEnumerable
    interface IEnumerable<'T>
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    member Tail : 'T list
    static member Cons : head:'T * tail:'T list -> 'T list
    static member Empty : 'T list

    Full name: Microsoft.FSharp.Collections.List<_>
    val sortBy : projection:('T -> 'Key) -> list:'T list -> 'T list (requires comparison)

    Full name: Microsoft.FSharp.Collections.List.sortBy
    val a : SqlDataProvider<...>.dataContext.public.albumdetailsEntity
    property SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Artist: string


    <summary> character varying(120)</summary>
    val getAlbum : id:int -> ctx:DbContext -> Album option

    Full name: SuaveMusicStore.Db.getAlbum
    property SqlDataProvider<...>.dataContext.public.albumsEntity.Albumid: int


    <summary> integer</summary>
    val deleteAlbum : album:Album -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.deleteAlbum
    val album : Album
    member Common.SqlEntity.Delete : unit -> unit
    SqlDataProvider<...>.dataContext.SubmitUpdates() : Unit


    <summary>Save changes to data-source. May throws errors: To deal with non-saved items use GetUpdates() and ClearUpdates().</summary>
    val getArtists : ctx:DbContext -> Artist list

    Full name: SuaveMusicStore.Db.getArtists
    property SqlDataProvider<...>.dataContext.publicSchema.Artists: SqlDataProvider<...>.dataContext.publicSchema.public.artists


    <summary> The base table artists belonging to schema public</summary>
    val createAlbum : artistId:int * genreId:int * price:decimal * title:string -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.createAlbum
    val artistId : int
    val genreId : int
    val price : decimal
    val title : string
    SqlDataProvider<...>.dataContext.publicSchema.public.albums.Create() : SqlDataProvider<...>.dataContext.public.albumsEntity
    SqlDataProvider<...>.dataContext.publicSchema.public.albums.Create(data: System.Collections.Generic.IEnumerable<string * obj>) : SqlDataProvider<...>.dataContext.public.albumsEntity


    <summary>Item array of database columns:
    artistid,genreid,price,title</summary>

    SqlDataProvider<...>.dataContext.publicSchema.public.albums.Create(artistid: int, genreid: int, price: decimal, title: string) : SqlDataProvider<...>.dataContext.public.albumsEntity
    val ignore : value:'T -> unit

    Full name: Microsoft.FSharp.Core.Operators.ignore
    val updateAlbum : album:Album -> artistId:int * genreId:int * price:decimal * title:string -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.updateAlbum
    property SqlDataProvider<...>.dataContext.public.albumsEntity.Artistid: int


    <summary> integer</summary>
    property SqlDataProvider<...>.dataContext.public.albumsEntity.Genreid: int


    <summary> integer</summary>
    property SqlDataProvider<...>.dataContext.public.albumsEntity.Price: decimal


    <summary> numeric</summary>
    property SqlDataProvider<...>.dataContext.public.albumsEntity.Title: string


    <summary> character varying(160)</summary>
    val validateUser : username:string * password:string -> ctx:DbContext -> User option

    Full name: SuaveMusicStore.Db.validateUser
    val username : string
    val password : string
    val user : SqlDataProvider<...>.dataContext.public.usersEntity
    property SqlDataProvider<...>.dataContext.publicSchema.Users: SqlDataProvider<...>.dataContext.publicSchema.public.users


    <summary> The base table users belonging to schema public</summary>
    property SqlDataProvider<...>.dataContext.public.usersEntity.Username: string


    <summary> character varying(200)</summary>
    property SqlDataProvider<...>.dataContext.public.usersEntity.Password: string


    <summary> character varying(200)</summary>
    val getCart : cartId:string -> albumId:int -> ctx:DbContext -> Cart option

    Full name: SuaveMusicStore.Db.getCart
    val cartId : string
    val albumId : int
    val cart : SqlDataProvider<...>.dataContext.public.cartsEntity
    property SqlDataProvider<...>.dataContext.publicSchema.Carts: SqlDataProvider<...>.dataContext.publicSchema.public.carts


    <summary> The base table carts belonging to schema public</summary>
    property SqlDataProvider<...>.dataContext.public.cartsEntity.Cartid: string


    <summary> character varying(50)</summary>
    property SqlDataProvider<...>.dataContext.public.cartsEntity.Albumid: int


    <summary> integer</summary>
    val addToCart : cartId:string -> albumId:int -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.addToCart
    union case Option.Some: Value: 'T -> Option<'T>
    val cart : Cart
    property SqlDataProvider<...>.dataContext.public.cartsEntity.Count: int


    <summary> integer</summary>
    union case Option.None: Option<'T>
    SqlDataProvider<...>.dataContext.publicSchema.public.carts.Create() : SqlDataProvider<...>.dataContext.public.cartsEntity
    SqlDataProvider<...>.dataContext.publicSchema.public.carts.Create(data: System.Collections.Generic.IEnumerable<string * obj>) : SqlDataProvider<...>.dataContext.public.cartsEntity


    <summary>Item array of database columns:
    albumid,cartid,count,datecreated</summary>

    SqlDataProvider<...>.dataContext.publicSchema.public.carts.Create(albumid: int, cartid: string, count: int, datecreated: System.DateTime) : SqlDataProvider<...>.dataContext.public.cartsEntity
    namespace System
    Multiple items
    type DateTime =
    struct
    new : ticks:int64 -> DateTime + 10 overloads
    member Add : value:TimeSpan -> DateTime
    member AddDays : value:float -> DateTime
    member AddHours : value:float -> DateTime
    member AddMilliseconds : value:float -> DateTime
    member AddMinutes : value:float -> DateTime
    member AddMonths : months:int -> DateTime
    member AddSeconds : value:float -> DateTime
    member AddTicks : value:int64 -> DateTime
    member AddYears : value:int -> DateTime
    ...
    end

    Full name: System.DateTime

    --------------------
    System.DateTime()
    (+0 other overloads)
    System.DateTime(ticks: int64) : unit
    (+0 other overloads)
    System.DateTime(ticks: int64, kind: System.DateTimeKind) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, calendar: System.Globalization.Calendar) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: System.DateTimeKind) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: System.Globalization.Calendar) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : unit
    (+0 other overloads)
    System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: System.DateTimeKind) : unit
    (+0 other overloads)
    property System.DateTime.UtcNow: System.DateTime
    val getCartsDetails : cartId:string -> ctx:DbContext -> CartDetails list

    Full name: SuaveMusicStore.Db.getCartsDetails
    val cart : SqlDataProvider<...>.dataContext.public.cartdetailsEntity
    property SqlDataProvider<...>.dataContext.publicSchema.Cartdetails: SqlDataProvider<...>.dataContext.publicSchema.public.cartdetails


    <summary> The view cartdetails belonging to schema public</summary>
    property SqlDataProvider<...>.dataContext.public.cartdetailsEntity.Cartid: string


    <summary> character varying(50)</summary>
    val removeFromCart : cart:Cart -> albumId:'a -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.removeFromCart
    val albumId : 'a
    val getCarts : cartId:string -> ctx:DbContext -> Cart list

    Full name: SuaveMusicStore.Db.getCarts
    val upgradeCarts : cartId:string * username:string -> ctx:DbContext -> Unit

    Full name: SuaveMusicStore.Db.upgradeCarts
    Multiple items
    val string : value:'T -> string

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

    --------------------
    type string = System.String

    Full name: Microsoft.FSharp.Core.string
    val existing : Cart
    val getUser : username:string -> ctx:DbContext -> User option

    Full name: SuaveMusicStore.Db.getUser
    val newUser : username:string * password:string * email:string -> ctx:DbContext -> SqlDataProvider<...>.dataContext.public.usersEntity

    Full name: SuaveMusicStore.Db.newUser
    val email : string
    SqlDataProvider<...>.dataContext.publicSchema.public.users.Create() : SqlDataProvider<...>.dataContext.public.usersEntity
    SqlDataProvider<...>.dataContext.publicSchema.public.users.Create(data: System.Collections.Generic.IEnumerable<string * obj>) : SqlDataProvider<...>.dataContext.public.usersEntity


    <summary>Item array of database columns:
    email,password,role,username</summary>

    SqlDataProvider<...>.dataContext.publicSchema.public.users.Create(email: string, password: string, role: string, username: string) : SqlDataProvider<...>.dataContext.public.usersEntity
    type IntPath = PrintfFormat<(int -> string),unit,string,string,int>

    Full name: SuaveMusicStore.Path.IntPath
    Multiple items
    type PrintfFormat<'Printer,'State,'Residue,'Result> =
    new : value:string -> PrintfFormat<'Printer,'State,'Residue,'Result>
    member Value : string

    Full name: Microsoft.FSharp.Core.PrintfFormat<_,_,_,_>

    --------------------
    type PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple> =
    inherit PrintfFormat<'Printer,'State,'Residue,'Result>
    new : value:string -> PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>

    Full name: Microsoft.FSharp.Core.PrintfFormat<_,_,_,_,_>

    --------------------
    new : value:string -> PrintfFormat<'Printer,'State,'Residue,'Result>

    --------------------
    new : value:string -> PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>
    Multiple items
    val int : value:'T -> int (requires member op_Explicit)

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

    --------------------
    type int = int32

    Full name: Microsoft.FSharp.Core.int

    --------------------
    type int<'Measure> = int

    Full name: Microsoft.FSharp.Core.int<_>
    type unit = Unit

    Full name: Microsoft.FSharp.Core.unit
    val withParam : key:string * value:string -> path:string -> string

    Full name: SuaveMusicStore.Path.withParam
    val key : string
    val value : string
    val path : string
    val sprintf : format:Printf.StringFormat<'T> -> 'T

    Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
    val home : string

    Full name: SuaveMusicStore.Path.home
    val overview : string

    Full name: SuaveMusicStore.Path.Store.overview
    val browse : string

    Full name: SuaveMusicStore.Path.Store.browse
    val details : IntPath

    Full name: SuaveMusicStore.Path.Store.details
    val browseKey : string

    Full name: SuaveMusicStore.Path.Store.browseKey
    val manage : string

    Full name: SuaveMusicStore.Path.Admin.manage
    val createAlbum : string

    Full name: SuaveMusicStore.Path.Admin.createAlbum
    val editAlbum : IntPath

    Full name: SuaveMusicStore.Path.Admin.editAlbum
    val deleteAlbum : IntPath

    Full name: SuaveMusicStore.Path.Admin.deleteAlbum
    val logon : string

    Full name: SuaveMusicStore.Path.Account.logon
    val logoff : string

    Full name: SuaveMusicStore.Path.Account.logoff
    val register : string

    Full name: SuaveMusicStore.Path.Account.register
    module Cart

    from SuaveMusicStore.Path
    val overview : string

    Full name: SuaveMusicStore.Path.Cart.overview
    val addAlbum : IntPath

    Full name: SuaveMusicStore.Path.Cart.addAlbum
    val removeAlbum : IntPath

    Full name: SuaveMusicStore.Path.Cart.removeAlbum
    val checkout : string

    Full name: SuaveMusicStore.Path.Cart.checkout
    namespace Suave
    module Form

    from Suave
    type Album =
    {ArtistId: decimal;
    GenreId: decimal;
    Title: string;
    Price: decimal;
    ArtUrl: string;}

    Full name: SuaveMusicStore.Form.Album
    Album.ArtistId: decimal
    Multiple items
    val decimal : value:'T -> decimal (requires member op_Explicit)

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

    --------------------
    type decimal = System.Decimal

    Full name: Microsoft.FSharp.Core.decimal

    --------------------
    type decimal<'Measure> = decimal

    Full name: Microsoft.FSharp.Core.decimal<_>
    Album.GenreId: decimal
    Album.Title: string
    Album.Price: decimal
    Album.ArtUrl: string
    val album : Form<Album>

    Full name: SuaveMusicStore.Form.album
    Multiple items
    union case Form.Form: FormProp<'a> list * ServerSideValidation<'a> list -> Form<'a>

    --------------------
    type Form<'a> = | Form of FormProp<'a> list * ServerSideValidation<'a> list

    Full name: Suave.Form.Form<_>
    union case FormProp.TextProp: Property<'a,string> -> FormProp<'a>
    val f : Album
    val maxLength : max:int -> Validation<string>

    Full name: Suave.Form.maxLength
    union case FormProp.DecimalProp: Property<'a,decimal> -> FormProp<'a>
    val min : min:decimal -> Validation<decimal>

    Full name: Suave.Form.min
    val max : max:decimal -> Validation<decimal>

    Full name: Suave.Form.max
    val step : step:System.Decimal -> Validation<decimal>

    Full name: Suave.Form.step
    type Logon =
    {Username: string;
    Password: Password;}

    Full name: SuaveMusicStore.Form.Logon
    Logon.Username: string
    Multiple items
    Logon.Password: Password

    --------------------
    type Password = | Password of string

    Full name: Suave.Form.Password
    val logon : Form<Logon>

    Full name: SuaveMusicStore.Form.logon
    type Register =
    {Username: string;
    Email: string;
    Password: Password;
    ConfirmPassword: Password;}

    Full name: SuaveMusicStore.Form.Register
    Register.Username: string
    Register.Email: string
    Multiple items
    Register.Password: Password

    --------------------
    type Password = | Password of string

    Full name: Suave.Form.Password
    Register.ConfirmPassword: Password
    Multiple items
    union case Password.Password: string -> Password

    --------------------
    type Password = | Password of string

    Full name: Suave.Form.Password
    val pattern : Validation<Password>

    Full name: SuaveMusicStore.Form.pattern
    val passwordRegex : pattern:string -> Validation<Password>

    Full name: Suave.Form.passwordRegex
    val passwordsMatch : (Register -> bool) * string

    Full name: SuaveMusicStore.Form.passwordsMatch
    val f : Register
    Register.Password: Password
    val register : Form<Register>

    Full name: SuaveMusicStore.Form.register
    union case FormProp.PasswordProp: Property<'a,Password> -> FormProp<'a>
    type Checkout =
    {FirstName: string;
    LastName: string;
    Address: string;
    PromoCode: string option;}

    Full name: SuaveMusicStore.Form.Checkout
    Checkout.FirstName: string
    Checkout.LastName: string
    Checkout.Address: string
    Checkout.PromoCode: string option
    Multiple items
    val option : value:string -> txt:string -> selected:bool -> Suave.Html.Node

    Full name: Suave.Form.option

    --------------------
    type 'T option = Option<'T>

    Full name: Microsoft.FSharp.Core.option<_>
    val checkout : Form<Checkout>

    Full name: SuaveMusicStore.Form.checkout
    module Html

    from Suave
    val em : s:string -> Node

    Full name: SuaveMusicStore.View.em
    val s : string
    val tag : tag:string -> attr:Attribute list -> contents:Node list -> Node

    Full name: Suave.Html.tag
    union case Node.Text: string -> Node
    val cssLink : href:string -> Node

    Full name: SuaveMusicStore.View.cssLink
    val href : string
    val link : attr:Attribute list -> Node

    Full name: Suave.Html.link
    val h2 : s:string -> Node

    Full name: SuaveMusicStore.View.h2
    val ul : nodes:Node list -> Node

    Full name: SuaveMusicStore.View.ul
    val nodes : Node list
    val ulAttr : attr:Attribute list -> nodes:Node list -> Node

    Full name: SuaveMusicStore.View.ulAttr
    val attr : Attribute list
    val li : (Node list -> Node)

    Full name: SuaveMusicStore.View.li
    val table : x:Node list -> Node

    Full name: SuaveMusicStore.View.table
    val x : Node list
    val th : x:Node list -> Node

    Full name: SuaveMusicStore.View.th
    val tr : x:Node list -> Node

    Full name: SuaveMusicStore.View.tr
    val td : x:Node list -> Node

    Full name: SuaveMusicStore.View.td
    val strong : s:string -> Node

    Full name: SuaveMusicStore.View.strong
    val text : s:string -> Node list

    Full name: Suave.Html.text
    val form : x:Node list -> Node

    Full name: SuaveMusicStore.View.form
    val formInput : (('a -> Quotations.Expr<'b>) -> Attribute list -> Form<'a> -> Node)

    Full name: SuaveMusicStore.View.formInput
    val input : quotF:('a -> Quotations.Expr<'b>) -> attrs:Attribute list -> form:Form<'a> -> Node

    Full name: Suave.Form.input
    val submitInput : value:string -> Node

    Full name: SuaveMusicStore.View.submitInput
    val input : attr:Attribute list -> Node

    Full name: Suave.Html.input
    type Field<'a> =
    {Label: string;
    Html: Form<'a> -> Node;}

    Full name: SuaveMusicStore.View.Field<_>
    Field.Label: string
    Multiple items
    Field.Html: Form<'a> -> Node

    --------------------
    type HtmlAttribute = string * string

    Full name: Suave.Form.HtmlAttribute
    Multiple items
    union case Form.Form: FormProp<'a> list * ServerSideValidation<'a> list -> Form<'a>

    --------------------
    module Form

    from SuaveMusicStore

    --------------------
    type Form<'a> = | Form of FormProp<'a> list * ServerSideValidation<'a> list

    Full name: Suave.Form.Form<_>
    type Node =
    | Element of Element * Node list
    | VoidElement of Element
    | Text of string
    | Raw of string
    | WhiteSpace of string

    Full name: Suave.Html.Node
    type Fieldset<'a> =
    {Legend: string;
    Fields: Field<'a> list;}

    Full name: SuaveMusicStore.View.Fieldset<_>
    Fieldset.Legend: string
    Fieldset.Fields: Field<'a> list
    type FormLayout<'a> =
    {Fieldsets: Fieldset<'a> list;
    SubmitText: string;
    Form: Form<'a>;}

    Full name: SuaveMusicStore.View.FormLayout<_>
    FormLayout.Fieldsets: Fieldset<'a> list
    FormLayout.SubmitText: string
    Multiple items
    FormLayout.Form: Form<'a>

    --------------------
    module Form

    from SuaveMusicStore

    --------------------
    type Form<'a> = | Form of FormProp<'a> list * ServerSideValidation<'a> list

    Full name: Suave.Form.Form<_>
    val renderForm : layout:FormLayout<'a> -> Node

    Full name: SuaveMusicStore.View.renderForm
    val layout : FormLayout<'a>
    val set : Fieldset<'a>
    val field : Field<'a>
    val div : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.div
    Field.Html: Form<'a> -> Node
    FormLayout.Form: Form<'a>
    val home : Node list

    Full name: SuaveMusicStore.View.home
    val store : genres:string list -> Node list

    Full name: SuaveMusicStore.View.store
    val genres : string list
    val p : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.p
    Multiple items
    module List

    from Microsoft.FSharp.Collections

    --------------------
    type List<'T> =
    | ( [] )
    | ( :: ) of Head: 'T * Tail: 'T list
    interface IEnumerable
    interface IEnumerable<'T>
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    member Tail : 'T list
    static member Cons : head:'T * tail:'T list -> 'T list
    static member Empty : 'T list

    Full name: Microsoft.FSharp.Collections.List<_>
    val length : list:'T list -> int

    Full name: Microsoft.FSharp.Collections.List.length
    val genre : string
    val url : string
    module Path

    from SuaveMusicStore
    module Store

    from SuaveMusicStore.Path
    val a : href:string -> attr:Attribute list -> (Node list -> Node)

    Full name: Suave.Html.a
    val browse : genre:string -> albums:Db.Album list -> Node list

    Full name: SuaveMusicStore.View.browse
    val albums : Db.Album list
    module Db

    from SuaveMusicStore
    type Album = FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity

    Full name: SuaveMusicStore.Db.Album
    val album : Db.Album
    val details : Path.IntPath

    Full name: SuaveMusicStore.Path.Store.details
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity.Albumid: int


    <summary> integer</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity.Title: string


    <summary> character varying(160)</summary>
    val details : album:Db.AlbumDetails -> Node list

    Full name: SuaveMusicStore.View.details
    val album : Db.AlbumDetails
    type AlbumDetails = FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity

    Full name: SuaveMusicStore.Db.AlbumDetails
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Title: string


    <summary> character varying(160)</summary>
    val img : attr:Attribute list -> Node

    Full name: Suave.Html.img
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Albumarturl: string


    <summary> character varying(1024)</summary>
    val caption : string
    val t : string
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Genre: string


    <summary> character varying(120)</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Artist: string


    <summary> character varying(120)</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Price: decimal


    <summary> numeric</summary>
    System.Decimal.ToString() : string
    System.Decimal.ToString(provider: System.IFormatProvider) : string
    System.Decimal.ToString(format: string) : string
    System.Decimal.ToString(format: string, provider: System.IFormatProvider) : string
    val addAlbum : Path.IntPath

    Full name: SuaveMusicStore.Path.Cart.addAlbum
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumdetailsEntity.Albumid: int


    <summary> integer</summary>
    val truncate : k:int -> s:string -> string

    Full name: SuaveMusicStore.View.truncate
    val k : int
    property System.String.Length: int
    System.String.Substring(startIndex: int) : string
    System.String.Substring(startIndex: int, length: int) : string
    val manage : albums:Db.AlbumDetails list -> Node list

    Full name: SuaveMusicStore.View.manage
    val albums : Db.AlbumDetails list
    module Admin

    from SuaveMusicStore.Path
    val editAlbum : Path.IntPath

    Full name: SuaveMusicStore.Path.Admin.editAlbum
    val deleteAlbum : Path.IntPath

    Full name: SuaveMusicStore.Path.Admin.deleteAlbum
    val deleteAlbum : albumTitle:string -> Node list

    Full name: SuaveMusicStore.View.deleteAlbum
    val albumTitle : string
    val br : attr:Attribute list -> Node

    Full name: Suave.Html.br
    val createAlbum : genres:(decimal * string) list -> artists:(decimal * string) list -> Node list

    Full name: SuaveMusicStore.View.createAlbum
    val genres : (decimal * string) list
    val artists : (decimal * string) list
    val album : Form<Form.Album>

    Full name: SuaveMusicStore.Form.album
    type HtmlAttribute = string * string

    Full name: Suave.Form.HtmlAttribute
    val selectInput : quotF:('a -> Quotations.Expr<'b>) -> options:('b * string) list -> selected:'b option -> form:Form<'a> -> Node (requires equality)

    Full name: Suave.Form.selectInput
    val f : Form.Album
    Form.Album.GenreId: decimal
    Form.Album.ArtistId: decimal
    Form.Album.Title: string
    Form.Album.Price: decimal
    Form.Album.ArtUrl: string
    val editAlbum : album:Db.Album -> genres:(decimal * string) list -> artists:(decimal * string) list -> Node list

    Full name: SuaveMusicStore.View.editAlbum
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity.Genreid: int


    <summary> integer</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity.Artistid: int


    <summary> integer</summary>
    val formatDec : d:System.Decimal -> string

    Full name: Suave.Form.formatDec
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.albumsEntity.Price: decimal


    <summary> numeric</summary>
    val logon : msg:string -> Node list

    Full name: SuaveMusicStore.View.logon
    val msg : string
    module Account

    from SuaveMusicStore.Path
    val logon : Form<Form.Logon>

    Full name: SuaveMusicStore.Form.logon
    val f : Form.Logon
    Form.Logon.Username: string
    Form.Logon.Password: Password
    val notFound : Node list

    Full name: SuaveMusicStore.View.notFound
    val partNav : cartItems:int -> Node

    Full name: SuaveMusicStore.View.partNav
    val cartItems : int
    val partUser : user:string option -> Node

    Full name: SuaveMusicStore.View.partUser
    val user : string option
    Multiple items
    val option : value:string -> txt:string -> selected:bool -> Node

    Full name: Suave.Form.option

    --------------------
    type 'T option = Option<'T>

    Full name: Microsoft.FSharp.Core.option<_>
    val user : string
    val emptyCart : Node list

    Full name: SuaveMusicStore.View.emptyCart
    val nonEmptyCart : carts:Db.CartDetails list -> Node list

    Full name: SuaveMusicStore.View.nonEmptyCart
    val carts : Db.CartDetails list
    type CartDetails = FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.cartdetailsEntity

    Full name: SuaveMusicStore.Db.CartDetails
    val h : string
    val cart : Db.CartDetails
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.cartdetailsEntity.Albumid: int


    <summary> integer</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.cartdetailsEntity.Albumtitle: string


    <summary> character varying(160)</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.cartdetailsEntity.Price: decimal


    <summary> numeric</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.cartdetailsEntity.Count: int


    <summary> integer</summary>
    System.Int32.ToString() : string
    System.Int32.ToString(provider: System.IFormatProvider) : string
    System.Int32.ToString(format: string) : string
    System.Int32.ToString(format: string, provider: System.IFormatProvider) : string
    val total : decimal
    val sumBy : projection:('T -> 'U) -> list:'T list -> 'U (requires member ( + ) and member get_Zero)

    Full name: Microsoft.FSharp.Collections.List.sumBy
    val c : Db.CartDetails
    val d : string
    val script : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.script
    val cart : _arg1:Db.CartDetails list -> Node list

    Full name: SuaveMusicStore.View.cart
    Multiple items
    val list : Db.CartDetails list

    --------------------
    type 'T list = List<'T>

    Full name: Microsoft.FSharp.Collections.list<_>
    val register : msg:string -> Node list

    Full name: SuaveMusicStore.View.register
    val register : Form<Form.Register>

    Full name: SuaveMusicStore.Form.register
    val f : Form.Register
    Form.Register.Username: string
    Form.Register.Email: string
    Form.Register.Password: Password
    Form.Register.ConfirmPassword: Password
    val checkout : Node list

    Full name: SuaveMusicStore.View.checkout
    val checkout : Form<Form.Checkout>

    Full name: SuaveMusicStore.Form.checkout
    val f : Form.Checkout
    Form.Checkout.FirstName: string
    Form.Checkout.LastName: string
    Form.Checkout.Address: string
    Form.Checkout.PromoCode: string option
    val index : partNav:Node -> partUser:Node -> container:Node list -> string

    Full name: SuaveMusicStore.View.index
    val partNav : Node
    val partUser : Node
    val container : Node list
    val html : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.html
    val head : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.head
    val title : attr:Attribute list -> s:string -> Node

    Full name: Suave.Html.title
    val body : (Attribute list -> Node list -> Node)

    Full name: Suave.Html.body
    val htmlToString : node:Node -> string

    Full name: Suave.Html.htmlToString
    module App

    from SuaveMusicStore
    module Authentication

    from Suave
    module Cookie

    from Suave
    module Filters

    from Suave
    module Model

    from Suave
    module Binding

    from Suave.Model
    module Operators

    from Suave
    module RequestErrors

    from Suave
    module State

    from Suave
    module CookieStateStore

    from Suave.State
    module Successful

    from Suave
    module Web

    from Suave
    type UserLoggedOnSession =
    {Username: string;
    Role: string;}

    Full name: SuaveMusicStore.App.UserLoggedOnSession
    UserLoggedOnSession.Username: string
    Multiple items
    val string : value:'T -> string

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

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

    Full name: Microsoft.FSharp.Core.string
    UserLoggedOnSession.Role: string
    Multiple items
    union case CookieLife.Session: CookieLife

    --------------------
    type Session =
    | NoSession
    | CartIdOnly of string
    | UserLoggedOn of UserLoggedOnSession

    Full name: SuaveMusicStore.App.Session
    union case Session.NoSession: Session
    union case Session.CartIdOnly: string -> Session
    union case Session.UserLoggedOn: UserLoggedOnSession -> Session
    val session : f:(Session -> HttpContext -> Async<'a option>) -> (HttpContext -> Async<'a option>)

    Full name: SuaveMusicStore.App.session
    val f : (Session -> HttpContext -> Async<'a option>)
    val statefulForSession : WebPart

    Full name: Suave.State.CookieStateStore.statefulForSession
    val context : apply:(HttpContext -> HttpContext -> 'a) -> context:HttpContext -> 'a

    Full name: Suave.Http.context
    val x : HttpContext
    Multiple items
    module HttpContext

    from Suave.State.CookieStateStore

    --------------------
    module HttpContext

    from Suave.Authentication

    --------------------
    module HttpContext

    from Suave.Http

    --------------------
    type HttpContext =
    {request: HttpRequest;
    runtime: HttpRuntime;
    connection: Connection;
    userState: Map<string,obj>;
    response: HttpResult;}
    member clientIp : trustProxy:bool -> sources:string list -> IPAddress
    member clientPort : trustProxy:bool -> sources:string list -> Port
    member clientProto : trustProxy:bool -> sources:string list -> string
    member clientIpTrustProxy : IPAddress
    member clientPortTrustProxy : Port
    member clientProtoTrustProxy : string
    member isLocal : bool
    static member clientIp_ : Property<HttpContext,IPAddress>
    static member clientPort_ : Property<HttpContext,Port>
    static member clientProto_ : Property<HttpContext,string>
    static member connection_ : Property<HttpContext,Connection>
    static member isLocal_ : Property<HttpContext,bool>
    static member request_ : Property<HttpContext,HttpRequest>
    static member response_ : Property<HttpContext,HttpResult>
    static member runtime_ : Property<HttpContext,HttpRuntime>
    static member userState_ : Property<HttpContext,Map<string,obj>>

    Full name: Suave.Http.HttpContext
    val state : ctx:HttpContext -> State.StateStore option

    Full name: Suave.State.CookieStateStore.HttpContext.state
    val state : State.StateStore
    abstract member State.StateStore.get : string -> 'T option
    val role : string
    val html : container:Html.Node list -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.html
    val container : Html.Node list
    val ctx : FSharp.Data.Sql.SqlDataProvider<...>.dataContext
    val getContext : unit -> FSharp.Data.Sql.SqlDataProvider<...>.dataContext

    Full name: SuaveMusicStore.Db.getContext
    val result : (int -> string option -> HttpContext -> Async<HttpContext option>)
    val OK : body:string -> WebPart

    Full name: Suave.Successful.OK
    module View

    from SuaveMusicStore
    val index : partNav:Html.Node -> partUser:Html.Node -> container:Html.Node list -> string

    Full name: SuaveMusicStore.View.index
    val partNav : cartItems:int -> Html.Node

    Full name: SuaveMusicStore.View.partNav
    val partUser : user:string option -> Html.Node

    Full name: SuaveMusicStore.View.partUser
    module Writers

    from Suave
    val setMimeType : mimeType:string -> WebPart

    Full name: Suave.Writers.setMimeType
    val items : int
    val getCartsDetails : cartId:string -> ctx:Db.DbContext -> Db.CartDetails list

    Full name: SuaveMusicStore.Db.getCartsDetails
    val browse : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.browse
    val request : apply:(HttpRequest -> HttpContext -> 'a) -> context:HttpContext -> 'a

    Full name: Suave.Http.request
    val r : HttpRequest
    member HttpRequest.queryParam : key:string -> Choice<string,string>
    union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>
    val getAlbumsForGenre : genreName:string -> ctx:Db.DbContext -> Db.Album list

    Full name: SuaveMusicStore.Db.getAlbumsForGenre
    val browse : genre:string -> albums:Db.Album list -> Html.Node list

    Full name: SuaveMusicStore.View.browse
    union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>
    val BAD_REQUEST : body:string -> WebPart

    Full name: Suave.RequestErrors.BAD_REQUEST
    val overview : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.overview
    val warbler : f:('t -> 't -> 'u) -> 't -> 'u

    Full name: Suave.WebPart.warbler
    val getGenres : ctx:Db.DbContext -> Db.Genre list

    Full name: SuaveMusicStore.Db.getGenres
    val map : mapping:('T -> 'U) -> list:'T list -> 'U list

    Full name: Microsoft.FSharp.Collections.List.map
    val g : Db.Genre
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.genresEntity.Name: string


    <summary> character varying(120)</summary>
    val store : genres:string list -> Html.Node list

    Full name: SuaveMusicStore.View.store
    val details : id:int -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.details
    val getAlbumDetails : id:int -> ctx:Db.DbContext -> Db.AlbumDetails option

    Full name: SuaveMusicStore.Db.getAlbumDetails
    val details : album:Db.AlbumDetails -> Html.Node list

    Full name: SuaveMusicStore.View.details
    val never : WebPart<'a>

    Full name: Suave.WebPart.never
    val manage : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.manage
    val getAlbumsDetails : ctx:Db.DbContext -> Db.AlbumDetails list

    Full name: SuaveMusicStore.Db.getAlbumsDetails
    val manage : albums:Db.AlbumDetails list -> Html.Node list

    Full name: SuaveMusicStore.View.manage
    val bindToForm : form:Form<'a> -> handler:('a -> HttpContext -> Async<HttpContext option>) -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.bindToForm
    val form : Form<'a>
    val handler : ('a -> HttpContext -> Async<HttpContext option>)
    val bindReq : f:(HttpRequest -> Choice<'b,'c>) -> fCont:('b -> HttpContext -> 'd) -> fErr:('c -> HttpContext -> 'd) -> (HttpContext -> 'd)

    Full name: Suave.Model.Binding.bindReq
    val bindForm : form:Form<'a> -> req:HttpRequest -> Choice<'a,string>

    Full name: Suave.Form.bindForm
    val createAlbum : WebPart<HttpContext>

    Full name: SuaveMusicStore.App.createAlbum
    val choose : options:WebPart<'a> list -> WebPart<'a>

    Full name: Suave.WebPart.choose
    val GET : WebPart

    Full name: Suave.Filters.GET
    Multiple items
    val decimal : value:'T -> decimal (requires member op_Explicit)

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

    --------------------
    type decimal = Decimal

    Full name: Microsoft.FSharp.Core.decimal

    --------------------
    type decimal<'Measure> = decimal

    Full name: Microsoft.FSharp.Core.decimal<_>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.genresEntity.Genreid: int


    <summary> integer</summary>
    val getArtists : ctx:Db.DbContext -> Db.Artist list

    Full name: SuaveMusicStore.Db.getArtists
    val g : Db.Artist
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.artistsEntity.Artistid: int


    <summary> integer</summary>
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.artistsEntity.Name: string


    <summary> character varying(120)</summary>
    val createAlbum : genres:(decimal * string) list -> artists:(decimal * string) list -> Html.Node list

    Full name: SuaveMusicStore.View.createAlbum
    val POST : WebPart

    Full name: Suave.Filters.POST
    Multiple items
    union case Form.Form: FormProp<'a> list * ServerSideValidation<'a> list -> Form<'a>

    --------------------
    module Form

    from Suave

    --------------------
    module Form

    from SuaveMusicStore

    --------------------
    type Form<'a> = | Form of FormProp<'a> list * ServerSideValidation<'a> list

    Full name: Suave.Form.Form<_>
    val form : Form.Album
    val createAlbum : artistId:int * genreId:int * price:decimal * title:string -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.createAlbum
    module Redirection

    from Suave
    val FOUND : location:string -> WebPart

    Full name: Suave.Redirection.FOUND
    val editAlbum : id:int -> WebPart<HttpContext>

    Full name: SuaveMusicStore.App.editAlbum
    val getAlbum : id:int -> ctx:Db.DbContext -> Db.Album option

    Full name: SuaveMusicStore.Db.getAlbum
    val editAlbum : album:Db.Album -> genres:(decimal * string) list -> artists:(decimal * string) list -> Html.Node list

    Full name: SuaveMusicStore.View.editAlbum
    val updateAlbum : album:Db.Album -> artistId:int * genreId:int * price:decimal * title:string -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.updateAlbum
    val deleteAlbum : id:int -> WebPart<HttpContext>

    Full name: SuaveMusicStore.App.deleteAlbum
    val deleteAlbum : albumTitle:string -> Html.Node list

    Full name: SuaveMusicStore.View.deleteAlbum
    val deleteAlbum : album:Db.Album -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.deleteAlbum
    val passHash : pass:string -> string

    Full name: SuaveMusicStore.App.passHash
    val pass : string
    val sha : Security.Cryptography.SHA256
    namespace System.Security
    namespace System.Security.Cryptography
    type SHA256 =
    inherit HashAlgorithm
    static member Create : unit -> SHA256 + 1 overload

    Full name: System.Security.Cryptography.SHA256
    Security.Cryptography.SHA256.Create() : Security.Cryptography.SHA256
    Security.Cryptography.SHA256.Create(hashName: string) : Security.Cryptography.SHA256
    namespace System.Text
    type Encoding =
    member BodyName : string
    member Clone : unit -> obj
    member CodePage : int
    member DecoderFallback : DecoderFallback with get, set
    member EncoderFallback : EncoderFallback with get, set
    member EncodingName : string
    member Equals : value:obj -> bool
    member GetByteCount : chars:char[] -> int + 3 overloads
    member GetBytes : chars:char[] -> byte[] + 5 overloads
    member GetCharCount : bytes:byte[] -> int + 2 overloads
    ...

    Full name: System.Text.Encoding
    property Text.Encoding.UTF8: Text.Encoding
    Text.Encoding.GetBytes(s: string) : byte []
    Text.Encoding.GetBytes(chars: char []) : byte []
    Text.Encoding.GetBytes(chars: char [], index: int, count: int) : byte []
    Text.Encoding.GetBytes(chars: nativeptr<char>, charCount: int, bytes: nativeptr<byte>, byteCount: int) : int
    Text.Encoding.GetBytes(s: string, charIndex: int, charCount: int, bytes: byte [], byteIndex: int) : int
    Text.Encoding.GetBytes(chars: char [], charIndex: int, charCount: int, bytes: byte [], byteIndex: int) : int
    Security.Cryptography.HashAlgorithm.ComputeHash(buffer: byte []) : byte []
    Security.Cryptography.HashAlgorithm.ComputeHash(inputStream: IO.Stream) : byte []
    Security.Cryptography.HashAlgorithm.ComputeHash(buffer: byte [], offset: int, count: int) : byte []
    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
    val b : byte
    Byte.ToString() : string
    Byte.ToString(provider: IFormatProvider) : string
    Byte.ToString(format: string) : string
    Byte.ToString(format: string, provider: IFormatProvider) : string
    Multiple items
    type String =
    new : value:char -> string + 7 overloads
    member Chars : int -> char
    member Clone : unit -> obj
    member CompareTo : value:obj -> int + 1 overload
    member Contains : value:string -> bool
    member CopyTo : sourceIndex:int * destination:char[] * destinationIndex:int * count:int -> unit
    member EndsWith : value:string -> bool + 2 overloads
    member Equals : obj:obj -> bool + 2 overloads
    member GetEnumerator : unit -> CharEnumerator
    member GetHashCode : unit -> int
    ...

    Full name: System.String

    --------------------
    String(value: nativeptr<char>) : unit
    String(value: nativeptr<sbyte>) : unit
    String(value: char []) : unit
    String(c: char, count: int) : unit
    String(value: nativeptr<char>, startIndex: int, length: int) : unit
    String(value: nativeptr<sbyte>, startIndex: int, length: int) : unit
    String(value: char [], startIndex: int, length: int) : unit
    String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Text.Encoding) : unit
    val concat : sep:string -> strings:seq<string> -> string

    Full name: Microsoft.FSharp.Core.String.concat
    val sessionStore : setF:(State.StateStore -> HttpContext -> Async<HttpContext option>) -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.sessionStore
    val setF : (State.StateStore -> HttpContext -> Async<HttpContext option>)
    val returnPathOrHome : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.returnPathOrHome
    val x : HttpRequest
    val authenticateUser : user:Db.User -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.authenticateUser
    val user : Db.User
    type User = FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.usersEntity

    Full name: SuaveMusicStore.Db.User
    val authenticated : relativeExpiry:CookieLife -> secure:bool -> WebPart

    Full name: Suave.Authentication.authenticated
    type CookieLife =
    | Session
    | MaxAge of duration: TimeSpan

    Full name: Suave.Cookie.CookieLife
    union case CookieLife.Session: CookieLife
    val upgradeCarts : cartId:string * username:string -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.upgradeCarts
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.usersEntity.Username: string


    <summary> character varying(200)</summary>
    val store : State.StateStore
    abstract member State.StateStore.set : string -> 'T -> WebPart
    val succeed : WebPart<'a>

    Full name: Suave.WebPart.succeed
    property FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.usersEntity.Role: string


    <summary> character varying(50)</summary>
    val logon : WebPart<HttpContext>

    Full name: SuaveMusicStore.App.logon
    val logon : msg:string -> Html.Node list

    Full name: SuaveMusicStore.View.logon
    val form : Form.Logon
    val validateUser : username:string * password:string -> ctx:Db.DbContext -> Db.User option

    Full name: SuaveMusicStore.Db.validateUser
    val register : WebPart<HttpContext>

    Full name: SuaveMusicStore.App.register
    val register : msg:string -> Html.Node list

    Full name: SuaveMusicStore.View.register
    val form : Form.Register
    val getUser : username:string -> ctx:Db.DbContext -> Db.User option

    Full name: SuaveMusicStore.Db.getUser
    val existing : Db.User
    val user : FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.usersEntity
    val newUser : username:string * password:string * email:string -> ctx:Db.DbContext -> FSharp.Data.Sql.SqlDataProvider<...>.dataContext.public.usersEntity

    Full name: SuaveMusicStore.Db.newUser
    val reset : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.reset
    val unsetPair : httpCookieName:string -> WebPart

    Full name: Suave.Cookie.unsetPair
    val SessionAuthCookie : string

    Full name: Suave.Authentication.SessionAuthCookie
    val StateCookie : string

    Full name: Suave.State.CookieStateStore.StateCookie
    val redirectWithReturnPath : redirection:string -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.redirectWithReturnPath
    val redirection : string
    HttpRequest.url: Uri
    property Uri.AbsolutePath: string
    val loggedOn : f_success:WebPart -> WebPart

    Full name: SuaveMusicStore.App.loggedOn
    val f_success : WebPart
    val authenticate : relativeExpiry:CookieLife -> secure:bool -> missingCookie:(unit -> Choice<byte [],WebPart>) -> decryptionFailure:(Utils.Crypto.SecretboxDecryptionError -> Choice<byte [],WebPart>) -> fSuccess:WebPart -> WebPart

    Full name: Suave.Authentication.authenticate
    val admin : f_success:(HttpContext -> Async<HttpContext option>) -> WebPart

    Full name: SuaveMusicStore.App.admin
    val f_success : (HttpContext -> Async<HttpContext option>)
    val FORBIDDEN : body:string -> WebPart

    Full name: Suave.RequestErrors.FORBIDDEN
    val UNAUTHORIZED : body:string -> WebPart

    Full name: Suave.RequestErrors.UNAUTHORIZED
    val cart : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.cart
    val emptyCart : Html.Node list

    Full name: SuaveMusicStore.View.emptyCart
    val cart : _arg1:Db.CartDetails list -> Html.Node list

    Full name: SuaveMusicStore.View.cart
    val addToCart : albumId:int -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.addToCart
    Multiple items
    type Guid =
    struct
    new : b:byte[] -> Guid + 4 overloads
    member CompareTo : value:obj -> int + 1 overload
    member Equals : o:obj -> bool + 1 overload
    member GetHashCode : unit -> int
    member ToByteArray : unit -> byte[]
    member ToString : unit -> string + 2 overloads
    static val Empty : Guid
    static member NewGuid : unit -> Guid
    static member Parse : input:string -> Guid
    static member ParseExact : input:string * format:string -> Guid
    ...
    end

    Full name: System.Guid

    --------------------
    Guid()
    Guid(b: byte []) : unit
    Guid(g: string) : unit
    Guid(a: int, b: int16, c: int16, d: byte []) : unit
    Guid(a: uint32, b: uint16, c: uint16, d: byte, e: byte, f: byte, g: byte, h: byte, i: byte, j: byte, k: byte) : unit
    Guid(a: int, b: int16, c: int16, d: byte, e: byte, f: byte, g: byte, h: byte, i: byte, j: byte, k: byte) : unit
    Guid.NewGuid() : Guid
    val addToCart : cartId:string -> albumId:int -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.addToCart
    val removeFromCart : albumId:int -> (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.removeFromCart
    val getCart : cartId:string -> albumId:int -> ctx:Db.DbContext -> Db.Cart option

    Full name: SuaveMusicStore.Db.getCart
    val cart : Db.Cart
    val removeFromCart : cart:Db.Cart -> albumId:'a -> ctx:Db.DbContext -> Unit

    Full name: SuaveMusicStore.Db.removeFromCart
    Multiple items
    module Html

    from Suave

    --------------------
    type HtmlAttribute = string * string

    Full name: Suave.Form.HtmlAttribute
    val htmlToString : node:Html.Node -> string

    Full name: Suave.Html.htmlToString
    val checkout : (HttpContext -> Async<HttpContext option>)

    Full name: SuaveMusicStore.App.checkout
    val checkout : Html.Node list

    Full name: SuaveMusicStore.View.checkout
    val webPart : WebPart<HttpContext>

    Full name: SuaveMusicStore.App.webPart
    val path : pathAfterDomain:string -> WebPart

    Full name: Suave.Filters.path
    val home : Html.Node list

    Full name: SuaveMusicStore.View.home
    val pathScan : pf:PrintfFormat<'a,'b,'c,'d,'t> -> h:('t -> WebPart) -> WebPart

    Full name: Suave.Filters.pathScan
    val removeAlbum : Path.IntPath

    Full name: SuaveMusicStore.Path.Cart.removeAlbum
    val pathRegex : pathAfterDomainRegex:string -> WebPart

    Full name: Suave.Filters.pathRegex
    module Files

    from Suave
    val browseHome : WebPart

    Full name: Suave.Files.browseHome
    val notFound : Html.Node list

    Full name: SuaveMusicStore.View.notFound
    val startWebServer : config:SuaveConfig -> webpart:WebPart -> unit

    Full name: Suave.Web.startWebServer
    val defaultConfig : SuaveConfig

    Full name: Suave.Web.defaultConfig

Show code from this section on GitHub

results matching ""

    No results matching ""