FSharp.Data.YamlValue 0.2.0

.NET 8.0 This package targets .NET 8.0. The package is compatible with this framework or higher. .NET Standard 2.0 This package targets .NET Standard 2.0. The package is compatible with this framework or higher.
There is a newer version of this package available.
See the version list below for details. 
dotnet add package FSharp.Data.YamlValue --version 0.2.0
                    


                    

                
NuGet\Install-Package FSharp.Data.YamlValue -Version 0.2.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="FSharp.Data.YamlValue" Version="0.2.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="FSharp.Data.YamlValue" Version="0.2.0" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="FSharp.Data.YamlValue" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add FSharp.Data.YamlValue --version 0.2.0
                    


                    

                
#r "nuget: FSharp.Data.YamlValue, 0.2.0"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package FSharp.Data.YamlValue@0.2.0
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=FSharp.Data.YamlValue&version=0.2.0
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=FSharp.Data.YamlValue&version=0.2.0
                    


                            Install as a Cake Tool

FSharp.Data.YamlValue

A YAML document API for F#, in the shape of FSharp.Data's JsonValue.

Parse YAML into a discriminated union you can pattern match, navigate with the ? dynamic operator, read with AsInteger()-style accessors, and write back out — including comments. Hand-written parser, zero dependencies, netstandard2.0/net8.0, AOT-compatible, and Fable-compatible (JavaScript and Python).

Install

dotnet add package FSharp.Data.YamlValue

Quick start

open FSharp.Data
open FSharp.Data.YamlExtensions

let info =
    YamlValue.Parse """
    name: Tomas          # given name
    born: 1985
    siblings:
      - Anna
      - Petr
    """

info?name.AsString()     // "Tomas"
info?born.AsInteger()    // 1985

for sibling in info?siblings do
    printfn "%s" (sibling.AsString())

Editing with SetPath/GetPath

YamlBuilders adds an immutable edit API with a string-path DSL, beyond what JsonValue offers:

open FSharp.Data.YamlValueBuilders

let doc = YamlValue.Parse """
name: myapp
services:
  web:
    image: nginx
"""

let updated = doc.SetPath("services.web.image", YamlValue.String "nginx:1.27")
updated.TryGetPath("services.web.image")   // Some (YamlValue.String "nginx:1.27")

Source positions and timestamp text

ParseWithPositions also returns the line/column/offset span of every node, keyed by JSON Pointer; ParseWithMetadata additionally keeps the original text of timestamps. Parse is unchanged.

let value, spans = YamlValue.ParseWithPositions "name: web\nports:\n  - 80\n"
spans.["/ports/0"].Start.Line      // 3

let parsed = YamlValue.ParseWithMetadata "released: 2026-10-14"
parsed.TimestampText.["/released"]  // "2026-10-14"

Learn more

License

MIT

Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 was computed.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
0.2.1 87 10/24/2026
0.2.0 99 10/23/2026
0.1.1 128 9/12/2026
0.1.0 121 9/11/2026

Fable support: the library compiles to JavaScript and Python from the same source (`#if FABLE_COMPILER` branches in a new internal `YamlPortable` module; the file/stream/URL loaders and `WriteTo(TextWriter)` are compiled out under Fable only). The shared test suite runs under Fable JS and Python via `scripts/fable-test.sh` (Fable 5.21.0 pinned in `.config/dotnet-tools.json`, generated runner in `scripts/fable-gen-runner.fsx`); see `docs/fable.md` for prerequisites and known differences. The .NET public API and behaviour are unchanged.
Original timestamp text: `YamlValue.ParseWithMetadata` (plus `TryParseWithMetadata` and `ParseMultipleWithMetadata`) returns a `YamlParsed` with the root value, the spans, and `TimestampText`, a map from JSON Pointer to the source text of each `Timestamp` (`2026-10-14` stays a date, a zoneless date-time stays zoneless). The `YamlValue` union and `Parse` are unchanged and still hold only the `DateTimeOffset`.
Source positions: `YamlValue.ParseWithPositions`, `TryParseWithPositions` and `ParseMultipleWithPositions` return a `Map<string, Span>` from RFC 6901 JSON Pointer (over the expanded tree) to the source span of every node, with new `Pos`, `Span` and `YamlParseError` types. Aliases and merged-in keys are positioned at the alias / `<<` site. `Parse` and its performance are unchanged; see `docs/reference.md`.
Portability fixes found by running under Fable: timestamps are built from components (Fable read `DateTimeOffset(DateTime, offset)` as local time, turning `07:08:09Z` into `05:08:09`), calendar-invalid timestamp-shaped text (`2024-02-30`, hour 25) is rejected up front, and `+5` parses under Fable. A huge exponent such as `1e999999` no longer builds a giant power of ten when deciding decimal-exactness. On .NET results are unchanged.
Every finite `Float` now round-trips as `Float`. A float whose plain text would resolve to `Number` (not just integral ones, but also decimal-exact values such as `0.5`, `1.5` or `0.1`, which emits as `0.10000000000000001`) is emitted with an explicit `!!float` tag, e.g. `!!float 1.5`. Floats whose plain text already re-parses as `Float` (e.g. `1.0000000000000001E+300`) are emitted exactly as before. The FsCheck generator no longer filters out these values.
Integral `Float` values (`1.0`, `-0.0`, `1e15`…`1e17`, …) now round-trip as `Float`. Previously they were emitted as `1`/`-0`/`1000000000000000` and re-parsed as `Number`; since `1.0` itself also parses as `Number` (it is exactly `decimal`-representable), they are now emitted with an explicit tag, e.g. `!!float 1.0` / `!!float -0.0`. Such a value used as a block-mapping key is emitted in explicit `? key` form, and the parser accepts a tagged scalar after `?`. Non-integral floats and `Number` output are unchanged.
Strings `"..."` and those starting with `"... "` are now quoted on emit so they are not re-read as a document end marker (`"---"` and `"--- "…` were already quoted via the leading-indicator rule; regression tests now cover them at the root and as keys/values).
The string `"<<"` is now quoted on emit, and a quoted `"<<"` mapping key in the source is treated as a literal key rather than a merge key (only the plain `<<` key merges), so `Parse(v.ToString())` round-trips a `"<<"` key instead of merging or dropping it.
Double-quoted scalars now accept JSON-style UTF-16 surrogate-pair escapes (e.g. `"\uD83C\uDF89"` parses to U+1F389) instead of failing with "Invalid Unicode code point". A lone/unpaired surrogate escape is still an error.