@nfdi4plants/arctrl 2.0.0-beta.1 → 2.0.0-beta.8

package/fable_modules/FsSpreadsheet.6.2.0/Json/Worksheet.fs.js

@@ -0,0 +1,109 @@
+import { seq } from "../../Thoth.Json.Core.0.2.1/Encode.fs.js";
+import { iterate, empty, isEmpty, append, singleton, collect, map, delay, toList } from "../../fable-library-js.4.16.0/Seq.js";
+import { decode as decode_1, encode, encodeNoNumbers } from "./Row.fs.js";
+import { FsCellsCollection__TryGetCell_Z37302880 } from "../Cells/FsCellsCollection.fs.js";
+import { FsCell } from "../Cells/FsCell.fs.js";
+import { rangeDouble } from "../../fable-library-js.4.16.0/Range.js";
+import { Json } from "../../Thoth.Json.Core.0.2.1/Types.fs.js";
+import { decode, encode as encode_1 } from "./Table.fs.js";
+import { seq as seq_1, string, object } from "../../Thoth.Json.Core.0.2.1/Decode.fs.js";
+import { defaultArg } from "../../fable-library-js.4.16.0/Option.js";
+import { FsWorksheet } from "../FsWorksheet.fs.js";
+import { decode as decode_2, encode as encode_2, encodeNoNumbers as encodeNoNumbers_1 } from "./Column.fs.js";
+
+export function encodeRows(noNumbering, sheet) {
+    sheet.RescanRows();
+    const jRows = noNumbering ? seq(toList(delay(() => map((r) => encodeNoNumbers(toList(delay(() => collect((c) => {
+        const matchValue = FsCellsCollection__TryGetCell_Z37302880(sheet.CellCollection, r, c);
+        return (matchValue == null) ? singleton(new FsCell("")) : singleton(matchValue);
+    }, rangeDouble(1, 1, sheet.MaxColumnIndex))))), rangeDouble(1, 1, sheet.MaxRowIndex))))) : seq(map(encode, sheet.Rows));
+    return new Json(5, [toList(delay(() => append(singleton(["name", new Json(0, [sheet.Name])]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode_1, sheet.Tables))]) : empty(), delay(() => singleton(["rows", jRows])))))))]);
+}
+
+export const decodeRows = object((builder) => {
+    let arg_5, objectArg_2;
+    let rowIndex = 0;
+    let n;
+    const objectArg = builder.Required;
+    n = objectArg.Field("name", string);
+    let ts;
+    const arg_3 = seq_1(decode);
+    const objectArg_1 = builder.Optional;
+    ts = objectArg_1.Field("tables", arg_3);
+    const rs = defaultArg((arg_5 = seq_1(decode_1), (objectArg_2 = builder.Optional, objectArg_2.Field("rows", arg_5))), empty());
+    const sheet = new FsWorksheet(n);
+    iterate((tupledArg) => {
+        const rowI = tupledArg[0];
+        let colIndex = 0;
+        const rowI_1 = ((rowI == null) ? (rowIndex + 1) : rowI) | 0;
+        rowIndex = (rowI_1 | 0);
+        const r = sheet.Row(rowI_1);
+        iterate((cell) => {
+            let colI;
+            const matchValue = cell.ColumnNumber | 0;
+            colI = ((matchValue === 0) ? (colIndex + 1) : matchValue);
+            colIndex = (colI | 0);
+            const c = r.Item(colI);
+            c.Value = cell.Value;
+            c.DataType = cell.DataType;
+        }, tupledArg[1]);
+    }, rs);
+    if (ts == null) {
+    }
+    else {
+        iterate((t) => {
+            sheet.AddTable(t);
+        }, ts);
+    }
+    return sheet;
+});
+
+export function encodeColumns(noNumbering, sheet) {
+    sheet.RescanRows();
+    const jColumns = noNumbering ? seq(toList(delay(() => map((c) => encodeNoNumbers_1(toList(delay(() => collect((r) => {
+        const matchValue = FsCellsCollection__TryGetCell_Z37302880(sheet.CellCollection, r, c);
+        return (matchValue == null) ? singleton(new FsCell("")) : singleton(matchValue);
+    }, rangeDouble(1, 1, sheet.MaxRowIndex))))), rangeDouble(1, 1, sheet.MaxColumnIndex))))) : seq(map(encode_2, sheet.Columns));
+    return new Json(5, [toList(delay(() => append(singleton(["name", new Json(0, [sheet.Name])]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode_1, sheet.Tables))]) : empty(), delay(() => singleton(["columns", jColumns])))))))]);
+}
+
+export const decodeColumns = object((builder) => {
+    let colIndex = 0;
+    let n;
+    const objectArg = builder.Required;
+    n = objectArg.Field("name", string);
+    let ts;
+    const arg_3 = seq_1(decode);
+    const objectArg_1 = builder.Optional;
+    ts = objectArg_1.Field("tables", arg_3);
+    let cs;
+    const arg_5 = seq_1(decode_2);
+    const objectArg_2 = builder.Required;
+    cs = objectArg_2.Field("columns", arg_5);
+    const sheet = new FsWorksheet(n);
+    iterate((tupledArg) => {
+        const colI = tupledArg[0];
+        let rowIndex = 0;
+        const colI_1 = ((colI == null) ? (colIndex + 1) : colI) | 0;
+        colIndex = (colI_1 | 0);
+        const col = sheet.Column(colI_1);
+        iterate((cell) => {
+            let rowI;
+            const matchValue = cell.RowNumber | 0;
+            rowI = ((matchValue === 0) ? (rowIndex + 1) : matchValue);
+            rowIndex = (rowI | 0);
+            const c = col.Item(rowIndex);
+            c.Value = cell.Value;
+            c.DataType = cell.DataType;
+        }, tupledArg[1]);
+    }, cs);
+    if (ts == null) {
+    }
+    else {
+        iterate((t) => {
+            sheet.AddTable(t);
+        }, ts);
+    }
+    return sheet;
+});
+

package/fable_modules/{FsSpreadsheet.6.1.2 → FsSpreadsheet.6.2.0}/obj/Release/netstandard2.0/FsSpreadsheet.AssemblyInfo.fs

@@ -10,10 +10,10 @@ open System.Reflection
 [<assembly: System.Reflection.AssemblyCompanyAttribute("Heinrich Lukas Weil, Oliver Maus, Kevin Schneider, Kevin Frey, Timo Mühlhaus")>]
 [<assembly: System.Reflection.AssemblyConfigurationAttribute("Release")>]
 [<assembly: System.Reflection.AssemblyDescriptionAttribute("Fable compliant Spreadsheet creation and manipulation in FSharp")>]
-[<assembly: System.Reflection.AssemblyFileVersionAttribute("6.1.2.0")>]
-[<assembly: System.Reflection.AssemblyInformationalVersionAttribute("6.1.2")>]
+[<assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")>]
+[<assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")>]
 [<assembly: System.Reflection.AssemblyProductAttribute("FsSpreadsheet")>]
 [<assembly: System.Reflection.AssemblyTitleAttribute("FsSpreadsheet")>]
-[<assembly: System.Reflection.AssemblyVersionAttribute("6.1.2.0")>]
+[<assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")>]
 [<assembly: System.Reflection.AssemblyMetadataAttribute("RepositoryUrl", "https://github.com/CSBiology/FsSpreadsheet")>]
 do()

package/fable_modules/YAMLicious.0.0.1/Decode.fs

@@ -0,0 +1,374 @@
+/// From YAML
+[<RequireQualifiedAccessAttribute>]
+module YAMLicious.Decode
+
+open System
+open System.Collections.Generic
+
+open YAMLicious
+open YAMLicious.YAMLiciousTypes
+open Fable.Core
+
+[<AutoOpen>]
+module Interop =
+
+    [<Erase>]
+    type IExports =
+        abstract Number: obj
+
+    [<ImportAll("numbers")>]
+    let numbers: IExports = nativeOnly
+
+    [<Global; Emit("list")>]
+    let pyList: obj = nativeOnly
+
+    [<Global; Emit("dict")>]
+    let pyDict: obj = nativeOnly
+
+    [<Global; Emit("int")>]
+    let pyInt: obj = nativeOnly
+
+    [<Global; Emit("bool")>]
+    let pyBool: obj = nativeOnly
+
+module Helper =
+
+    let inline raiseInvalidArg (name: string) (message: string) wrongV = 
+        invalidArg name (sprintf "%s: %A" message wrongV)
+
+    //let isInt (value: string) =
+    //    #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+    //    JsInterop.isInt value
+    //    #else
+    //    match System.Int32.TryParse value with
+    //    | true, _ -> true
+    //    | false, _ -> false
+    //    #endif
+
+    //let isFloat (value: string) =
+    //    #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+    //    JsInterop.isInt value
+    //    #else
+    //    match System.Double.TryParse value with
+    //    | true, _ -> true
+    //    | false, _ -> false
+    //    #endif
+
+    let isString (value: string) =
+        #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+        JsInterop.isString value
+        #endif
+        #if FABLE_COMPILER_PYTHON
+        YAMLicious.PyInterop.isString value
+        #endif
+        #if !FABLE_COMPILER
+        match System.Char.TryParse value with
+        | true, _ -> true
+        | false, _ -> false
+        #endif
+
+open Helper
+let int (value: YAMLElement) : int =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match System.Int32.TryParse v.Value with
+        | true, v -> v
+        | false, _ -> raiseInvalidArg "value" "Expected an int" v.Value
+    | _ -> raiseInvalidArg "value" "Expected an YAMLElement.Value" value
+
+let float (value: YAMLElement) : float =
+    let Culture = System.Globalization.CultureInfo.InvariantCulture
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        #if FABLE_COMPILER
+        match System.Double.TryParse(v.Value) with // numberstyle and culture return not implemented warning
+        #else
+        match System.Double.TryParse(v.Value, System.Globalization.NumberStyles.Float, Culture) with
+        #endif
+        | true, v -> float v
+        | false, _ -> raiseInvalidArg "value" "Expected an int" v.Value
+    | _ -> raiseInvalidArg "value" "Expected an YAMLElement.Value" value
+
+let char (value: YAMLElement) : char =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match isString v.Value with
+        | true -> v.Value.[0]
+        | _ -> Helper.raiseInvalidArg "value" "Expected a char" v.Value
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a char" anyElse
+
+let bool (value: YAMLElement) : bool =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match System.Boolean.TryParse v.Value with
+        | true, bool -> bool
+        | false, _ -> Helper.raiseInvalidArg "value" "Expected a bool" v.Value
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a bool" anyElse
+
+let map (keyDecoder: string -> 'a) (valueDecoder: YAMLElement -> 'b) (value: YAMLElement) : Map<'a, 'b> =
+    match value with
+    | YAMLElement.Object v -> 
+        v |> List.map (fun x -> 
+            match x with
+            | YAMLElement.Mapping (k, v) -> (keyDecoder k.Value, valueDecoder v)
+            | anyElse -> Helper.raiseInvalidArg "value" "Expected a mapping" x
+        ) |> Map.ofList
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a map" anyElse
+
+let dict (keyDecoder: string -> 'a) (valueDecoder: YAMLElement -> 'b) (value: YAMLElement) : Dictionary<'a, 'b> =
+    match value with
+    | YAMLElement.Object v -> 
+        v |> List.map (fun x -> 
+            match x with
+            | YAMLElement.Mapping (k, v) -> (keyDecoder k.Value, valueDecoder v)
+            | anyElse -> Helper.raiseInvalidArg "value" "Expected a mapping" anyElse
+        ) |> Map |> Dictionary
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a dictionary" anyElse
+
+let datetime (value: YAMLElement) : DateTime =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match System.DateTime.TryParse(v.Value) with
+        | true, dateTime -> dateTime
+        | false, _ -> Helper.raiseInvalidArg "value" "Expected a DateTime" v.Value
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a DateTime" anyElse
+
+let datetimeOffset (value: YAMLElement) : DateTimeOffset =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match System.DateTimeOffset.TryParse(v.Value) with
+        | true, dateTimeOffset -> dateTimeOffset
+        | false, _ -> Helper.raiseInvalidArg "value" "Expected a DateTimeOffset" v.Value
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a DateTimeOffset" anyElse
+
+let option (decoder: YAMLElement -> 'a) (value: YAMLElement) : 'a option =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> 
+        match v.Value with
+        | YAML_NULL -> None
+        | _ -> Some (decoder value)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected an option" anyElse
+
+let string (value: YAMLElement) : string =
+    match value with
+    | YAMLElement.Value v | YAMLElement.Object [YAMLElement.Value v] -> v.Value
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a string" anyElse
+
+let tuple2 (decoderA: YAMLElement -> 'a) (decoderB: YAMLElement -> 'b) (value: YAMLElement) : 'a * 'b =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b]] | YAMLElement.Sequence [a; b] -> (decoderA a, decoderB b)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple2" anyElse
+
+let tuple3 (decoderA: YAMLElement -> 'a) (decoderB: YAMLElement -> 'b) (decoderC: YAMLElement -> 'c) (value: YAMLElement) : 'a * 'b * 'c =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c]] | YAMLElement.Sequence [a; b; c] -> (decoderA a, decoderB b, decoderC c)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple3" anyElse
+
+let tuple4 
+    (decoderA: YAMLElement -> 'a) 
+    (decoderB: YAMLElement -> 'b) 
+    (decoderC: YAMLElement -> 'c) 
+    (decoderD: YAMLElement -> 'd) 
+    (value: YAMLElement) 
+    : 'a * 'b * 'c * 'd 
+    =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c; d]] | YAMLElement.Sequence [a; b; c; d] -> (decoderA a, decoderB b, decoderC c, decoderD d)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple4" anyElse
+
+let tuple5 
+    (decoderA: YAMLElement -> 'a) 
+    (decoderB: YAMLElement -> 'b) 
+    (decoderC: YAMLElement -> 'c) 
+    (decoderD: YAMLElement -> 'd) 
+    (decoderE: YAMLElement -> 'e) 
+    (value: YAMLElement) 
+    : 'a * 'b * 'c * 'd * 'e 
+    =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c; d; e]] | YAMLElement.Sequence [a; b; c; d; e] -> (decoderA a, decoderB b, decoderC c, decoderD d, decoderE e)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple5" anyElse
+
+let tuple6
+    (decoderA: YAMLElement -> 'a) 
+    (decoderB: YAMLElement -> 'b) 
+    (decoderC: YAMLElement -> 'c) 
+    (decoderD: YAMLElement -> 'd) 
+    (decoderE: YAMLElement -> 'e) 
+    (decoderF: YAMLElement -> 'f) 
+    (value: YAMLElement) 
+    : 'a * 'b * 'c * 'd * 'e * 'f 
+    =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c; d; e; f]] 
+    | YAMLElement.Sequence [a; b; c; d; e; f] -> 
+        (decoderA a, decoderB b, decoderC c, decoderD d, decoderE e, decoderF f)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple6" anyElse
+
+let tuple7
+    (decoderA: YAMLElement -> 'a) 
+    (decoderB: YAMLElement -> 'b) 
+    (decoderC: YAMLElement -> 'c) 
+    (decoderD: YAMLElement -> 'd) 
+    (decoderE: YAMLElement -> 'e) 
+    (decoderF: YAMLElement -> 'f) 
+    (decoderG: YAMLElement -> 'g) 
+    (value: YAMLElement) 
+    : 'a * 'b * 'c * 'd * 'e * 'f * 'g 
+    =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c; d; e; f; g]] 
+    | YAMLElement.Sequence [a; b; c; d; e; f; g] -> 
+        (decoderA a, decoderB b, decoderC c, decoderD d, decoderE e, decoderF f, decoderG g)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple7" anyElse
+
+let tuple8
+    (decoderA: YAMLElement -> 'a) 
+    (decoderB: YAMLElement -> 'b) 
+    (decoderC: YAMLElement -> 'c) 
+    (decoderD: YAMLElement -> 'd) 
+    (decoderE: YAMLElement -> 'e) 
+    (decoderF: YAMLElement -> 'f) 
+    (decoderG: YAMLElement -> 'g) 
+    (decoderH: YAMLElement -> 'h) 
+    (value: YAMLElement) 
+    : 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h 
+    =
+    match value with
+    | YAMLElement.Object [YAMLElement.Sequence [a; b; c; d; e; f; g; h]] 
+    | YAMLElement.Sequence [a; b; c; d; e; f; g; h] -> 
+        (decoderA a, decoderB b, decoderC c, decoderD d, decoderE e, decoderF f, decoderG g, decoderH h)
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a tuple8" anyElse
+
+let list (decoder: YAMLElement -> 'a) (value: YAMLElement) : 'a list =
+    match value with
+    | YAMLElement.Sequence v | YAMLElement.Object [YAMLElement.Sequence v] -> 
+        v |> List.map decoder
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a list" anyElse
+
+let array (decoder: YAMLElement -> 'a) (value: YAMLElement) : 'a [] =
+    match value with
+    | YAMLElement.Sequence v | YAMLElement.Object [YAMLElement.Sequence v] -> 
+        v |> List.map decoder |> List.toArray
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected an array" anyElse
+
+let seq (decoder: YAMLElement -> 'a) (value: YAMLElement) : seq<'a> =
+    match value with
+    | YAMLElement.Sequence v | YAMLElement.Object [YAMLElement.Sequence v] -> 
+        v |> Seq.map decoder
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a seq" anyElse
+
+let resizearray (decoder: YAMLElement -> 'a) (value: YAMLElement) : ResizeArray<'a> =
+    match value with
+    | YAMLElement.Sequence v | YAMLElement.Object [YAMLElement.Sequence v] -> 
+        v |> List.map decoder |> ResizeArray
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a resizearray" anyElse
+
+let values (decoder: YAMLElement -> 'a) (value: YAMLElement) : 'a list =
+    match value with
+    | YAMLElement.Sequence v | YAMLElement.Object [YAMLElement.Sequence v] | YAMLElement.Object v -> 
+        v 
+        |> List.map (function 
+            | YAMLElement.Value _ as v -> decoder v 
+            | anyElse -> Helper.raiseInvalidArg "value" "Expected a values" anyElse
+        )
+    | anyElse -> Helper.raiseInvalidArg "value" "Expected a values" anyElse
+
+module ObjectHelper =
+
+    type IRequiredGetter =
+        abstract Field: string -> (YAMLElement -> 'a) -> 'a
+        //abstract At: List<string> -> Decoder<'a> -> 'a
+        //abstract Raw: Decoder<'a> -> 'a
+
+    type IOptionalGetter =
+        abstract Field: string -> (YAMLElement -> 'a) -> 'a option
+        //abstract At: List<string> -> Decoder<'a> -> 'a option
+        //abstract Raw: Decoder<'a> -> 'a option
+
+    type IOverflowGetter =
+        abstract FieldList: string list -> Dictionary<string, YAMLElement>
+
+
+open ObjectHelper
+
+type IGetters =
+    abstract Required: IRequiredGetter
+    abstract Optional: IOptionalGetter
+    abstract Overflow: IOverflowGetter
+
+type Getter(ele: YAMLElement) =
+    let required = 
+        { new IRequiredGetter with 
+            member _.Field fieldName dec =  
+                match ele with
+                | YAMLElement.Object v ->
+                    //printfn "[GETTER] IsObject"
+                    v 
+                    |> List.tryFind (function 
+                        | YAMLElement.Mapping (k, _) -> 
+                            //printfn "[GETTER] IsMapping"
+                            let equals = k.Value = fieldName
+                            //printfn "[GETTER] Equals: %A" equals
+                            equals
+                        | _ -> false
+                    )
+                    |> Option.map (function 
+                        | YAMLElement.Mapping (_, v) -> 
+                            //printfn "[GETTER] Mapping: %A" v
+                            dec v
+                        | _ -> Helper.raiseInvalidArg "value" "Expected a mapping" ele
+                    )
+                    |> fun x ->
+                        if x .IsNone then 
+                            Helper.raiseInvalidArg "value" (sprintf "Field not found: %s" fieldName) ele
+                        else x.Value
+                | anyElse -> Helper.raiseInvalidArg "value" "Expected an object" anyElse
+        }
+    let optional =
+        { new IOptionalGetter with 
+            member this.Field (fieldName: string) (dec: YAMLElement -> 'a) = 
+                match ele with
+                | YAMLElement.Object v ->
+                    v 
+                    |> List.tryFind (function 
+                        | YAMLElement.Mapping (k, _) -> k.Value = fieldName
+                        | _ -> false
+                    )
+                    |> Option.map (function 
+                        | YAMLElement.Mapping (_, v) -> dec v
+                        | _ -> Helper.raiseInvalidArg "value" "Expected a mapping" ele
+                    )
+                | anyElse -> Helper.raiseInvalidArg "value" "Expected an object" anyElse
+        }
+    let overflow =
+        { new IOverflowGetter with 
+            member this.FieldList (fieldNames: string list) = 
+                match ele with
+                | YAMLElement.Object v ->
+                    let overflow =
+                        v 
+                        |> List.filter (function 
+                            | YAMLElement.Mapping (k, _) -> fieldNames |> List.exists (fun x -> x = k.Value)
+                            | _ -> false
+                        )
+                        |> List.map (function 
+                            | YAMLElement.Mapping (k, v) -> (k.Value, v)
+                            | _ -> Helper.raiseInvalidArg "value" "Expected a mapping" ele
+                        )
+                    let dict = new Dictionary<string, YAMLElement>()
+                    overflow |> List.iter (fun (k, v) -> dict.Add(k, v))
+                    dict
+                | anyElse -> Helper.raiseInvalidArg "value" "Expected an object" anyElse
+        }
+    interface IGetters with
+        member __.Required = required
+        member __.Optional = optional
+        member __.Overflow = overflow
+
+let object (getter: IGetters -> 'a) (value: YAMLElement) : 'a =
+    let getterObj = Getter(value) :> IGetters
+    getter getterObj
+
+let read (yaml: string) = 
+    Reader.read yaml