/// The MIT License (MIT)

/// Copyright (c) 2016 Bazinga Technologies Inc

namespace FSharp.Data.GraphQL.Types

open System

open System.Collections.Concurrent

open Hopac

open Hopac.Extensions

open FSharp.Data.GraphQL

open FSharp.Data.GraphQL.Ast

[<Flags; Serializable>]

type DirectiveLocation =

| QUERY = 1

| MUTATION = 2

| SUBSCRIPTION = 4

| FIELD = 8

| FRAGMENT_DEFINITION = 16

| FRAGMENT_SPREAD = 32

| INLINE_FRAGMENT = 64

module Introspection =

[<Serializable>]

type TypeKind =

| SCALAR = 1

| OBJECT = 2

| INTERFACE = 3

| UNION = 4

| ENUM = 5

| INPUT_OBJECT = 6

| LIST = 7

| NON_NULL = 8

[<Serializable>]

type IntrospectionDirective =

{ Name : string

Description : string option

Locations : DirectiveLocation []

Args : IntrospectionInputVal [] }

and [<Serializable>] IntrospectionType =

{ Kind : TypeKind

Name : string

Description : string option

Fields : IntrospectionField [] option

Interfaces : IntrospectionTypeRef [] option

PossibleTypes : IntrospectionTypeRef [] option

EnumValues : IntrospectionEnumVal [] option

InputFields : IntrospectionInputVal [] option

OfType : IntrospectionTypeRef option }

static member Scalar(name: string, description: string option) =

{ Kind = TypeKind.SCALAR

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = None

InputFields = None

OfType = None }

static member Object(name: string, description: string option, fields: IntrospectionField [], interfaces: IntrospectionTypeRef []) =

{ Kind = TypeKind.OBJECT

Name = name

Description = description

Fields = Some fields

Interfaces = Some interfaces

PossibleTypes = None

EnumValues = None

InputFields = None

OfType = None }

static member InputObject(name: string, description: string option, inputFields: IntrospectionInputVal []) =

{ Kind = TypeKind.INPUT_OBJECT

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = None

InputFields = Some inputFields

OfType = None }

static member Union(name: string, description: string option, possibleTypes: IntrospectionTypeRef []) =

{ Kind = TypeKind.UNION

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = Some possibleTypes

EnumValues = None

InputFields = None

OfType = None }

static member Enum(name: string, description: string option, enumValues: IntrospectionEnumVal []) =

{ Kind = TypeKind.ENUM

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = Some enumValues

InputFields = None

OfType = None }

static member Interface(name: string, description: string option, fields: IntrospectionField [], possibleTypes: IntrospectionTypeRef []) =

{ Kind = TypeKind.INTERFACE

Name = name

Description = description

Fields = Some fields

Interfaces = None

PossibleTypes = Some possibleTypes

EnumValues = None

InputFields = None

OfType = None }

and [<Serializable>] IntrospectionTypeRef =

{ Kind : TypeKind

Name : string option

Description : string option

OfType : IntrospectionTypeRef option }

static member List(inner: IntrospectionTypeRef) = { Kind = TypeKind.LIST; Name = None; Description = None; OfType = Some inner }

static member NonNull(inner: IntrospectionTypeRef) = { Kind = TypeKind.NON_NULL; Name = None; Description = None; OfType = Some inner }

static member Named(inner: IntrospectionType) = { Kind = inner.Kind; Name = Some inner.Name; Description = inner.Description; OfType = None }

and [<Serializable>] IntrospectionInputVal =

{ Name : string

Description : string option

Type : IntrospectionTypeRef

DefaultValue : string option }

and [<Serializable>] IntrospectionEnumVal =

{ Name : string

Description : string option

IsDeprecated : bool

DeprecationReason : string option }

and [<Serializable>] IntrospectionField =

{ Name : string

Description : string option

Args : IntrospectionInputVal []

Type : IntrospectionTypeRef

IsDeprecated : bool

DeprecationReason : string option }

and [<Serializable>] IntrospectionSchema =

{ QueryType : IntrospectionTypeRef

MutationType : IntrospectionTypeRef option

SubscriptionType : IntrospectionTypeRef option

Types : IntrospectionType []

Directives : IntrospectionDirective [] }

type ISchema =

interface

inherit seq<NamedDef>

abstract TypeMap : Map<string, NamedDef>

abstract Query : ObjectDef

abstract Mutation : ObjectDef option

abstract Directives : DirectiveDef []

abstract TryFindType : string -> NamedDef option

abstract GetPossibleTypes : AbstractDef -> ObjectDef []

abstract IsPossibleType : AbstractDef -> ObjectDef -> bool

abstract Introspected : Introspection.IntrospectionSchema

end

// 3.1 Types

and TypeDef =

interface

abstract MakeList: unit -> ListOfDef

abstract MakeNullable: unit -> NullableDef

end

and TypeDef<'Val> =

interface

inherit TypeDef

end

and InputDef =

interface

inherit TypeDef

abstract InputType: Type

end

and InputDef<'Val> =

interface

inherit InputDef

inherit TypeDef<'Val>

end

and OutputDef =

interface

inherit TypeDef

abstract OutputType: Type

end

and OutputDef<'Val> =

interface

inherit OutputDef

inherit TypeDef<'Val>

end

and LeafDef =

interface

inherit TypeDef

end

and CompositeDef =

interface

inherit TypeDef

end

and AbstractDef =

interface

inherit TypeDef

end

and NamedDef =

interface

inherit TypeDef

abstract Name : string

end

and ExecuteField = ResolveFieldContext -> obj -> Job<obj>

and FieldDef =

interface

abstract Name : string

abstract Description : string option

abstract DeprecationReason : string option

abstract Type : OutputDef

abstract Args : InputFieldDef []

abstract Resolve : ResolveFieldContext -> obj -> Job<obj>

abstract Execute : ExecuteField with get,set

inherit IEquatable<FieldDef>

end

and FieldDef<'Val> =

interface

abstract Resolve : ResolveFieldContext -> 'Val -> Job<obj>

inherit FieldDef

end

and ExecutionContext =

{

Schema: ISchema

RootValue: obj

Document: Document

Operation: OperationDefinition

Fragments: FragmentDefinition list

Variables: Map<string, obj>

Errors: ConcurrentBag<exn>

}

and ResolveFieldContext =

{ FieldName : string

Fields : Field []

FieldType : FieldDef

ReturnType : TypeDef

ParentType : ObjectDef

Schema : ISchema

Args : Map<string, obj>

Operation : OperationDefinition

Fragments : FragmentDefinition list

Variables : Map<string, obj>

ExecutionContext: ExecutionContext

AddError: exn -> unit }

member x.TryArg(name : string) : 't option =

match Map.tryFind name x.Args with

| Some o -> Some(o :?> 't)

| None -> None

member x.Arg(name : string) : 't =

downcast Map.find name x.Args

and ScalarDef =

interface

abstract Name : string

abstract Description : string option

abstract CoerceInput : Value -> obj option

abstract CoerceOutput : obj -> Value option

abstract CoerceValue : obj -> obj option

inherit IEquatable<ScalarDef>

inherit TypeDef

inherit NamedDef

inherit InputDef

inherit OutputDef

inherit LeafDef

end

/// 3.1.1.1 Build-in Scalars

and [<CustomEquality; NoComparison>] ScalarDefinition<'Val> =

{ Name : string

Description : string option

CoerceInput : Value -> 'Val option

CoerceOutput : 'Val -> Value option

CoerceValue : obj -> 'Val option }

interface InputDef with

member __.InputType = typeof<'Val>

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val>

interface ScalarDef with

member x.Name = x.Name

member x.Description = x.Description

member x.CoerceInput input = x.CoerceInput input |> Option.map box

member x.CoerceOutput output = x.CoerceOutput(output :?> 'Val)

member x.CoerceValue value = (x.CoerceValue value) |> Option.map box

interface InputDef<'Val>

interface OutputDef<'Val>

interface LeafDef

interface NamedDef with

member x.Name = x.Name

interface IEquatable<ScalarDef> with

member x.Equals s = x.Name = s.Name

override x.Equals y =

match y with

| :? ScalarDef as s -> (x :> IEquatable<ScalarDef>).Equals(s)

| _ -> false

override x.GetHashCode() = x.Name.GetHashCode()

override x.ToString() = x.Name

and EnumVal =

interface

abstract Name : string

abstract Description : string option

abstract Value : obj

abstract DeprecationReason : string option

end

and EnumValue<'Val> =

{ Name : string

Value : 'Val

Description : string option

DeprecationReason : string option }

interface EnumVal with

member x.Name = x.Name

member x.Description = x.Description

member x.DeprecationReason = x.DeprecationReason

member x.Value = upcast x.Value

override x.ToString() = x.Name

and EnumDef =

interface

abstract Name : string

abstract Description : string option

abstract Options : EnumVal []

inherit TypeDef

inherit InputDef

inherit OutputDef

inherit LeafDef

inherit NamedDef

end

and EnumDef<'Val> =

interface

abstract Options : EnumValue<'Val> []

inherit EnumDef

inherit TypeDef<'Val>

inherit InputDef<'Val>

inherit OutputDef<'Val>

end

and EnumDefinition<'Val> =

{ Name : string

Description : string option

Options : EnumValue<'Val> [] }

interface InputDef with

member __.InputType = typeof<'Val>

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val>

interface EnumDef<'Val> with

member x.Options = x.Options

interface EnumDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Options =

x.Options

|> Seq.ofArray

|> Seq.cast<EnumVal>

|> Seq.toArray

interface NamedDef with

member x.Name = x.Name

override x.ToString() = sprintf "enum %s {\n %s\n}" x.Name (String.Join("\n ", x.Options))

/// 3.1.2 Objects

and ObjectDef =

interface

abstract Name : string

abstract Description : string option

abstract Fields : FieldDef []

abstract Implements : InterfaceDef []

abstract IsTypeOf : (obj -> bool) option

inherit TypeDef

inherit NamedDef

inherit OutputDef

inherit CompositeDef

inherit IEquatable<ObjectDef>

end

and ObjectDef<'Val> =

interface

abstract Fields : FieldDef<'Val> []

inherit ObjectDef

inherit TypeDef<'Val>

inherit OutputDef<'Val>

end

and [<CustomEquality; NoComparison>] ObjectDefinition<'Val> =

{ Name : string

Description : string option

FieldsFn : Lazy<FieldDef<'Val> []>

Implements : InterfaceDef []

IsTypeOf : (obj -> bool) option }

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val>

interface ObjectDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Fields =

x.FieldsFn.Force()

|> Seq.ofArray

|> Seq.cast<FieldDef>

|> Seq.toArray

member x.Implements = x.Implements

member x.IsTypeOf = x.IsTypeOf

interface ObjectDef<'Val> with

member x.Fields = x.FieldsFn.Force()

interface NamedDef with

member x.Name = x.Name

interface IEquatable<ObjectDef> with

member x.Equals f = x.Name = f.Name

override x.Equals y =

match y with

| :? ObjectDef as f -> (x :> IEquatable<ObjectDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash

override x.ToString() =

let sb = System.Text.StringBuilder("type ")

sb.Append(x.Name) |> ignore

if not (Array.isEmpty x.Implements) then

sb.Append(" implements ").Append(String.Join(", ", x.Implements |> Array.map (fun i -> i.Name))) |> ignore

sb.Append("{") |> ignore

//x.Fields |> List.iter (fun f -> sb.Append("\n ").Append(f.ToString()) |> ignore)

sb.Append("\n}").ToString()

and [<CustomEquality; NoComparison>] FieldDefinition<'Val, 'Res> =

{ Name : string

Description : string option

Type : OutputDef<'Res>

Resolve : ResolveFieldContext -> 'Val -> Job<'Res>

Args : InputFieldDef []

DeprecationReason : string option

mutable Execute : ExecuteField }

interface FieldDef with

member x.Name = x.Name

member x.Description = x.Description

member x.DeprecationReason = x.DeprecationReason

member x.Type = x.Type :> OutputDef

member x.Args = x.Args

member x.Resolve (ctx : ResolveFieldContext) (value : obj) : Job<obj> =

x.Resolve ctx (value :?> 'Val)

|> Job.map (fun x -> upcast x)

member x.Execute with get() = x.Execute and set v = x.Execute <- v

interface FieldDef<'Val> with

member x.Resolve (ctx : ResolveFieldContext) (value : 'Val) : Job<obj> =

x.Resolve ctx value

|> Job.map (fun x -> upcast x)

interface IEquatable<FieldDef> with

member x.Equals f = x.Name = f.Name && x.Type :> OutputDef = f.Type && x.Args = f.Args

override x.Equals y =

match y with

| :? FieldDef as f -> (x :> IEquatable<FieldDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash <- (hash * 397) ^^^ (x.Type.GetHashCode())

hash <- (hash * 397) ^^^ (x.Args.GetHashCode())

hash

override x.ToString() =

let mutable s = x.Name + ": " + x.Type.ToString()

if not (Array.isEmpty x.Args) then s <- "(" + String.Join(", ", x.Args) + ")"

s

/// 3.1.3 Interfaces

and InterfaceDef =

interface

abstract Name : string

abstract Description : string option

abstract Fields : FieldDef []

abstract ResolveType : (obj -> ObjectDef) option

inherit TypeDef

inherit OutputDef

inherit CompositeDef

inherit AbstractDef

inherit NamedDef

inherit IEquatable<InterfaceDef>

end

and InterfaceDef<'Val> =

interface

abstract Fields : FieldDef<'Val> []

inherit TypeDef<'Val>

inherit OutputDef<'Val>

inherit InterfaceDef

end

and [<CustomEquality; NoComparison>] InterfaceDefinition<'Val> =

{ Name : string

Description : string option

FieldsFn : unit -> FieldDef<'Val> []

ResolveType : (obj -> ObjectDef) option }

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val>

interface InterfaceDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Fields = x.FieldsFn() |> Array.map (fun fdef -> upcast fdef)

member x.ResolveType = x.ResolveType

interface InterfaceDef<'Val> with

member x.Fields = x.FieldsFn()

interface NamedDef with

member x.Name = x.Name

interface IEquatable<InterfaceDef> with

member x.Equals f = x.Name = f.Name

override x.Equals y =

match y with

| :? InterfaceDef as f -> (x :> IEquatable<InterfaceDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash

override x.ToString() =

let sb = System.Text.StringBuilder("interface ").Append(x.Name).Append(" {")

// x.Fields |> List.iter (fun f -> sb.Append("\n ").Append(f.ToString()) |> ignore)

sb.Append("\n}").ToString()

and UnionDef =

interface

abstract Name : string

abstract Description : string option

abstract Options : ObjectDef []

abstract ResolveType : (obj -> ObjectDef) option

abstract ResolveValue : obj -> obj

inherit TypeDef

inherit OutputDef

inherit CompositeDef

inherit AbstractDef

inherit NamedDef

inherit IEquatable<UnionDef>

end

and UnionDef<'In> =

interface

abstract ResolveType : ('In -> ObjectDef) option

abstract ResolveValue : 'In -> obj

inherit UnionDef

inherit TypeDef<'In>

inherit OutputDef<'In>

end

/// 3.1.4 Unions

and [<CustomEquality; NoComparison>] UnionDefinition<'In, 'Out> =

{ Name : string

Description : string option

Options : ObjectDef []

ResolveType : ('In -> ObjectDef) option

ResolveValue : 'In -> 'Out }

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Out>

interface UnionDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Options = x.Options

member x.ResolveType = x.ResolveType |> Option.map (fun fn -> (fun value -> fn (value :?> 'In)))

member x.ResolveValue value = upcast x.ResolveValue(value :?> 'In)

interface UnionDef<'In> with

member x.ResolveType = x.ResolveType

member x.ResolveValue value = upcast x.ResolveValue value

interface NamedDef with

member x.Name = x.Name

interface IEquatable<UnionDef> with

member x.Equals f = x.Name = f.Name && x.Description = f.Description && x.Options = f.Options

override x.Equals y =

match y with

| :? InterfaceDef as f -> (x :> IEquatable<UnionDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash <- (hash * 397) ^^^ (x.Options.GetHashCode())

hash

override x.ToString() = "union " + x.Name + " = " + String.Join(" | ", x.Options |> Array.map (fun o -> o.Name))

and ListOfDef =

interface

abstract OfType : TypeDef

inherit InputDef

inherit OutputDef

end

and ListOfDef<'Val> =

interface

abstract OfType : TypeDef<'Val>

inherit TypeDef<'Val seq>

inherit InputDef<'Val seq>

inherit OutputDef<'Val seq>

end

and ListOfDefinition<'Val> =

{ OfType : TypeDef<'Val> }

interface InputDef with

member __.InputType = typeof<'Val seq>

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val seq>

interface ListOfDef with

member x.OfType = upcast x.OfType

interface ListOfDef<'Val> with

member x.OfType = x.OfType

override x.ToString() =

match x.OfType with

| :? NamedDef as named -> "[" + named.Name + "]"

| other -> "[" + other.ToString() + "]"

and NullableDef =

interface

abstract OfType : TypeDef

inherit InputDef

inherit OutputDef

end

and NullableDef<'Val> =

interface

abstract OfType : TypeDef<'Val>

inherit InputDef<'Val option>

inherit OutputDef<'Val option>

end

and NullableDefinition<'Val> =

{ OfType : TypeDef<'Val> }

interface InputDef with

member __.InputType = typeof<'Val option>

interface TypeDef with

member x.MakeNullable() = upcast x

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

interface OutputDef with

member __.OutputType = typeof<'Val option>

interface NullableDef with

member x.OfType = upcast x.OfType

interface NullableDef<'Val> with

member x.OfType = x.OfType

override x.ToString() =

match x.OfType with

| :? NamedDef as named -> named.Name.Substring(0, named.Name.Length - 1) // remobe bang on sufix

| other -> other.ToString()

and InputObjectDef =

interface

abstract Name : string

abstract Description : string option

abstract Fields : InputFieldDef []

inherit NamedDef

inherit InputDef

end

/// 3.1.6 Input Objects

and InputObjectDefinition<'Val> =

{ Name : string

Description : string option

FieldsFn : unit -> InputFieldDef [] }

interface InputDef with

member __.InputType = typeof<'Val>

interface InputObjectDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Fields = x.FieldsFn()

interface TypeDef<'Val>

interface InputDef<'Val>

interface NamedDef with

member x.Name = x.Name

interface TypeDef with

member x.MakeNullable() =

let nullable: NullableDefinition<_> = { OfType = x }

upcast nullable

member x.MakeList() =

let list: ListOfDefinition<_> = { OfType = x }

upcast list

and ExecuteInput = Map<string,obj> -> Value -> obj

and InputFieldDef =

interface

abstract Name : string

abstract Description : string option

abstract Type : InputDef

abstract DefaultValue : obj option

abstract ExecuteInput : ExecuteInput with get,set

inherit IEquatable<InputFieldDef>

end

/// 3.1.2.1 Object Field Arguments

and [<CustomEquality; NoComparison>] InputFieldDefinition<'In> =

{ Name : string

Description : string option

Type : InputDef<'In>

DefaultValue : 'In option

mutable ExecuteInput: ExecuteInput }

interface InputFieldDef with

member x.Name = x.Name

member x.Description = x.Description

member x.Type = upcast x.Type

member x.DefaultValue = x.DefaultValue |> Option.map (fun x -> upcast x)

member x.ExecuteInput with get () = x.ExecuteInput and set v = x.ExecuteInput <- v

interface IEquatable<InputFieldDef> with

member x.Equals f = x.Name = f.Name && x.Type :> InputDef = f.Type

override x.Equals y =

match y with

| :? InputFieldDef as f -> (x :> IEquatable<InputFieldDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash <- (hash * 397) ^^^ (x.Type.GetHashCode())

hash

override x.ToString() = x.Name

/// 5.7 Variables

and Variable =

{ Name : string

Schema : TypeDef

DefaultValue : obj }

override x.ToString() =

"$" + x.Name + ": " + x.Schema.ToString() + (if x.DefaultValue <> null then " = " + x.DefaultValue.ToString()

else "")

and DirectiveDef =

{ Name : string

Description : string option

Locations : DirectiveLocation

Args : InputFieldDef [] }

[<AutoOpen>]

module SchemaDefinitions =

open System.Globalization

open System.Reflection

let internal coerceIntValue (x : obj) : int option =

match x with

| null -> None

| :? int as i -> Some i

| :? int64 as l -> Some(int l)

| :? double as d -> Some(int d)

| :? string as s ->

match Int32.TryParse(s) with

| true, i -> Some i

| false, _ -> None

| :? bool as b ->

Some(if b then 1

else 0)

| other ->

try

Some(System.Convert.ToInt32 other)

with _ -> None

let internal coerceFloatValue (x : obj) : double option =

match x with

| null -> None

| :? int as i -> Some(double i)

| :? int64 as l -> Some(double l)

| :? double as d -> Some d

| :? string as s ->

match Double.TryParse(s) with

| true, i -> Some i

| false, _ -> None

| :? bool as b ->

Some(if b then 1.

else 0.)

| other ->

try

Some(System.Convert.ToDouble other)

with _ -> None

let internal coerceBoolValue (x : obj) : bool option =

match x with

| null -> None

| :? int as i -> Some(i <> 0)

| :? int64 as l -> Some(l <> 0L)

| :? double as d -> Some(d <> 0.)

| :? string as s ->

match Boolean.TryParse(s) with

| true, i -> Some i

| false, _ -> None

| :? bool as b -> Some b

| other ->

try

Some(System.Convert.ToBoolean other)

with _ -> None

let internal coerceUriValue (x : obj) : Uri option =

match x with

| null -> None

| :? Uri as u -> Some u

| :? string as s ->

match Uri.TryCreate(s, UriKind.RelativeOrAbsolute) with

| true, uri -> Some uri

| false, _ -> None

| other -> None

let internal coerceDateValue (x : obj) : DateTime option =

match x with

| null -> None

| :? DateTime as d -> Some d

| :? string as s ->

match DateTime.TryParse(s) with

| true, date -> Some date

| false, _ -> None

| other -> None

let private coerceIntOuput (x : obj) =

match x with

| :? int as y -> Some(IntValue y)

| _ -> None

let private coerceFloatOuput (x : obj) =

match x with

| :? float as y -> Some(FloatValue y)

| _ -> None

let private coerceBoolOuput (x : obj) =

match x with

| :? bool as y -> Some(BooleanValue y)

| _ -> None

let private coerceStringOuput (x : obj) =

match x with

| :? string as y -> Some(StringValue y)

| _ -> None

let private coerceUriOutput (x : obj) =

match x with

| :? Uri as uri -> Some(StringValue (uri.ToString()))

| _ -> None

let private coerceDateOutput (x : obj) =

match x with

| :? DateTime as date -> Some(StringValue (date.ToString("O")))

| _ -> None

/// Check if provided obj value is an Option and extract its wrapped value as object if possible

let (|Option|_|) (x : obj) =

if x = null then None

else

let t = x.GetType()

if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<option<_>> then

let _, fields = Microsoft.FSharp.Reflection.FSharpValue.GetUnionFields(x, t)

Some(fields.[0])

else None

let internal coerceStringValue (x : obj) : string option =

match x with

| null -> None

| :? string as s -> Some s

| :? bool as b ->

Some(if b then "true"

else "false")

| Option o -> Some(o.ToString())

| _ -> Some(x.ToString())

let private coerceIntInput =

function

| IntValue i -> Some i

| FloatValue f -> Some(int f)

| StringValue s ->

match Int32.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture) with

| true, i -> Some i

| false, _ -> None

| BooleanValue b ->

Some(if b then 1

else 0)

| _ -> None

let private coerceFloatInput =

function

| IntValue i -> Some(double i)

| FloatValue f -> Some f

| StringValue s ->

match Double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture) with

| true, i -> Some i

| false, _ -> None

| BooleanValue b ->

Some(if b then 1.

else 0.)

| _ -> None