The spec suggests that the exponents are base 8, as are all other numbers in dson, but the example given of 42very3 -> 24e3 suggests that exponents are base 10 rather than being base 8 in which case the example should be 42very3 -> 17408 and most of the standard-compliant implementations are wrong including mine.

In a base 8 exponent, the base should be multiplied by 8 to the power N for N being a base 8 number, whereas the given example shows that while N may be read in base 8, the exponent part is not in base 8 but is in base 10, that is the expression is M_10^N rather than M_8^N.

Hey, I made this a long time ago and forgot about it http://dsonlint.github.io/. Not sure if anyone else has done one. Might be cool to link it from the main pages, as I think it's a cool way to show off the spec.

New implementation over at https://github.com/arrdem/dogeon

https://github.com/gabstv/dson2json

dson := `such "foo" is so no and yes many wow`
in0 := bytes.NewBufferString(dson)
out0 := new(bytes.Buffer)
dson2json.Convert(in0, out0)
fmt.Println(out0.String()) // prints {"foo":[false,true]}

I could add as a pull request too if it's easier.

Hi,
I wrote a new implementation for DSON standard in Go programming language. It's easy to use and implement in a project.

Kindly review https://github.com/muhammadmuzzammil1998/dsongo and add it to the list of libraries of DSON on the website.

dson.go can:

• Encode from JSON to DSON
• Decode from DSON to JSON
• Validate DSON
• Marshal a Go structure to DSON
• Unmarshal DSON to a Go structure

Examples

Install dson.go first

$ go get muzzammil.xyz/dsongo

Common imports

import (
    "fmt"

    "muzzammil.xyz/dsongo"
)

Encoding JSON into DSON

func main() {
    d := dson.Encode(`{"foo":"bar"}`)
    fmt.Println(d) // such "foo" is "bar" wow
}

Decoding DSON into JSON

func main() {
    j := dson.Decode(`such "foo" is "bar" wow`)
    fmt.Println(j) // {"foo":"bar"}
}

Validating DSON

func main() {
    if dson.Valid(`such "foo" is "bar" wow`) {
        fmt.Println("Valid DSON")
    } else {
        fmt.Println("Invalid DSON")
    }
}

Marshaling DSON

func main() {
    type ColorGroup struct {
        ID     int
        Name   string
        Colors []string
    }
    RedGroup := ColorGroup{
        ID:     1,
        Name:   "Reds",
        Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
    }
    r, err := dson.Marshal(RedGroup)
    if err == nil && dson.Valid(r) {
        fmt.Println(r) // such "ID" is 1! "Name" is "Reds". "Colors" is so "Crimson" and "Red" and "Ruby" also "Maroon" many wow
    }
}

Unmarshaling DSON

func main() {
    d := `so such "Name" is "Platypus" and "Order" is "Monotremata" wow and such "Name" is "Quoll" and "Order" is "Dasyuromorphia" wow many`
    if !dson.Valid(d) {
        fmt.Println("DSON is not valid")
        return
    }
    type Animal struct {
        Name  string
        Order string
    }
    var animals []Animal
    err := dson.Unmarshal(d, &animals)
    if err == nil {
        fmt.Printf("%+v", animals) // [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
    }
}

Thanks!

https://github.com/bhaeussermann/DSON-Java

It may be buggy, and until issue #3 is cleared up, it can't be considered finished. However, initial tests have demonstrated that it works (or that my tests aren't good enough :D), and I would be honored if it could be included in the list of parsers.

https://github.com/TheRabbitologist/libDSON

such sad

I think there has been some confusion... The master branch is not up to date with the dsongo-by-muhammad branch thats why it doesn't show on the website. Please merge them.

Previous issue: #17

Thanks! :)

https://github.com/vpzomtrrfrt/DSON

Hey!

I made a theoretically very correct Haskell implementation.
I think it's the only implementation so far that reads octal numbers with decimal point and an exponent correctly.

https://github.com/alvare/dson-parsec

https://crates.io/crates/doge

I am starting a JVM DOGESON parser to piggyback on top of JSON serializers.
Written in Scala with a Java wrapper
Initial implementation can be found here:
https://github.com/erosas/VeryDogeon

There is a need for more extensive examples with edge cases so that programmers can test their implementations.