anchor.diff:              , fun (v : Value) -> v.GetBoolean() |> translate |> box)
   
   type ITypeContext =
  +    abstract member GetNamedTypes : CoreVariableType seq
       abstract member GetTranslator : targetType : System.Type -> TypeTranslator option
   
   type IValueConverter =
  +    abstract member GetNamedTypes : CoreVariableType seq
       abstract member VariableTypeOf : targetType : System.Type -> VariableType
       abstract member TranslateValueTo : ty : System.Type * value : Value -> obj
   
   type BuiltinTypeContext() =
  +    static let integer (convert : int64 -> 'a) name (min, max) =
  +        new TypeTranslator
  +            ( typeof<'a>
  +            ,
  +                ({ new ISchemaVariableType with
  +                    member this.TypeName = name
  +                    member this.CoreType = PrimitiveType IntType
  +                    member this.ValidateValue(value) =
  +                        match value with
  +                        | PrimitiveValue (IntPrimitive i) ->
  +                            i >= min && i <= max
  +                        | _ -> false
  +                } |> NamedType).NotNullable()
  +            , fun v -> v.GetInteger() |> convert |> box
  +            )
  +    static let floating (convert : double -> 'a) name =
  +        new TypeTranslator
  +            ( typeof<'a>
  +            ,
  +                ({ new ISchemaVariableType with
  +                    member this.TypeName = name
  +                    member this.CoreType = PrimitiveType FloatType
  +                    member this.ValidateValue(value) = true
  +                } |> NamedType).NotNullable()
  +            , fun v -> v.GetFloat() |> convert |> box
  +            )
       static let builtinTypes =
           [
  -            TypeTranslator.Integer(Checked.int8)
  -            TypeTranslator.Integer(Checked.int16)
  -            TypeTranslator.Integer(Checked.int32)
  -            TypeTranslator.Integer(Checked.int64)
  -            TypeTranslator.Integer(Checked.uint8)
  -            TypeTranslator.Integer(Checked.uint16)
  -            TypeTranslator.Integer(Checked.uint32)
  -            TypeTranslator.Integer(Checked.uint64)
  -
  -            TypeTranslator.Float(single)
  -            TypeTranslator.Float(double)
  -            TypeTranslator.Float(decimal)
  +            integer int8 "Int8" (int64 SByte.MinValue, int64 SByte.MaxValue)
  +            integer int16 "Int16" (int64 Int16.MinValue, int64 Int16.MaxValue)
  +            integer int32 "Int" (int64 Int32.MinValue, int64 Int32.MaxValue)
  +            integer int64 "Int64" (Int64.MinValue, Int64.MaxValue)
  +            integer uint8 "UInt8" (int64 Byte.MinValue, int64 Byte.MaxValue)
  +            integer uint16 "UInt16" (int64 UInt16.MinValue, int64 UInt16.MaxValue)
  +            integer uint32 "UInt32" (int64 UInt32.MinValue, int64 UInt32.MaxValue)
  +            integer uint64 "UInt64" (Int64.MinValue, Int64.MaxValue) // maybe we shouldn't support this - representing ulongs with negative #s
  +
  +            floating double "Float"
  +            floating single "Float32"
  +            floating decimal "Decimal"
   
               TypeTranslator.String(id)
   
               TypeTranslator.Boolean(id)
           ] |> Seq.map (fun t -> t.CLRType, t) |> dictionary
       interface ITypeContext with
  +        member this.GetNamedTypes =
  +            builtinTypes.Values
  +            |> Seq.map (fun t -> t.VariableType.Type)
           member this.GetTranslator(targetType) = builtinTypes.TryFind(targetType)
   
   type ChainTypeContext(primary : ITypeContext, fallback : ITypeContext) =
       interface ITypeContext with
  +        member this.GetNamedTypes = Seq.append primary.GetNamedTypes fallback.GetNamedTypes
           member this.GetTranslator(targetType) =
               match primary.GetTranslator(targetType) with
               | Some r -> Some r
  
positive.code:     let mutable context : ITypeContext = Unchecked.defaultof<ITypeContext>
      do
          context <-
              new BuiltinTypeContext()
              |??| new NullableTypeContext(this :> IValueConverter)
              |??| new ArrayTypeContext(this :> IValueConverter)
              |??| new CollectionTypeContext(this :> IValueConverter)
              |??| new EnumerableTypeContext(this :> IValueConverter)
              |??| new SingleConstructorTypeContext(this :> IValueConverter)
              |??| customContext(this :> IValueConverter)
      interface IValueConverter with
          // TODO: cache translators for CLR types
          member this.VariableTypeOf(targetType) =
              match context.GetTranslator(targetType) with
  
negative.code: ﻿namespace GraphQL.Parser
  open System
  open System.Reflection
  open System.Collections.Generic
  
  