rs-05-json-value

0.000

0/1 tests· architecture

Challenge · difficulty 5/5

# JSON parser to a typed value

Implement the library file **`src/lib.rs`** exposing a parser for a subset of JSON:

```rust
pub fn parse(input: &str) -> Result<Value, ParseError>

pub enum Value {
    Null,
    Bool(bool),
    Number(f64),
    Str(String),
    Array(Vec<Value>),
    Object(Vec<(String, Value)>),
}

pub struct ParseError { /* your fields — e.g. a message and position */ }
```

Derive `Debug`, `Clone`, and `PartialEq` for `Value` so it can be compared in tests.

Parse a single JSON value from `input` and return it as a `Value`, or `Err(ParseError)` if the
input is not valid. Support:

- **Literals**: `null`, `true`, `false`.
- **Numbers**: parsed as `f64` (integers, negatives, decimals, and exponents like `1e3`).
- **Strings**: double-quoted, with the escapes `\" \\ \/ \n \t \r \b \f` and `\uXXXX`.
- **Arrays**: `[`, comma-separated values, `]`. May be empty (`[]`).
- **Objects**: `{`, comma-separated `"key": value` members, `}`. May be empty (`{}`). **Preserve
  member order** exactly as it appears in the input (hence `Vec<(String, Value)>`, not a map).
- **Whitespace** (spaces, tabs, newlines, carriage returns) is allowed and ignored between tokens.

Errors (return `Err`, do not panic):
- malformed tokens, unterminated strings, missing `:`/`,`/closing brackets;
- **trailing characters** after a complete value (e.g. `"null null"` is an error).

Tests live in `tests/` and call `challenge::parse` and `challenge::Value`.

tests/json_value.rs

use challenge::{parse, Value};

#[test]
fn parses_primitives() {
    assert_eq!(parse("null"), Ok(Value::Null));
    assert_eq!(parse("true"), Ok(Value::Bool(true)));
    assert_eq!(parse("false"), Ok(Value::Bool(false)));
    assert_eq!(parse("42"), Ok(Value::Number(42.0)));
    assert_eq!(parse("-3.5"), Ok(Value::Number(-3.5)));
    assert_eq!(parse("1e3"), Ok(Value::Number(1000.0)));
    assert_eq!(parse("\"hi\""), Ok(Value::Str("hi".to_string())));
}

#[test]
fn ignores_surrounding_whitespace() {
    assert_eq!(parse("  \n true \t "), Ok(Value::Bool(true)));
}

#[test]
fn parses_string_escapes() {
    assert_eq!(parse("\"a\\nb\""), Ok(Value::Str("a\nb".to_string())));
    assert_eq!(parse("\"q\\\"q\""), Ok(Value::Str("q\"q".to_string())));
}

#[test]
fn parses_empty_array_and_object() {
    assert_eq!(parse("[]"), Ok(Value::Array(vec![])));
    assert_eq!(parse("{}"), Ok(Value::Object(vec![])));
}

#[test]
fn parses_nested_structures() {
    let parsed = parse("{\"a\": [1, 2], \"b\": {\"c\": true}}").unwrap();
    let expected = Value::Object(vec![
        ("a".to_string(), Value::Array(vec![Value::Number(1.0), Value::Number(2.0)])),
        ("b".to_string(), Value::Object(vec![("c".to_string(), Value::Bool(true))])),
    ]);
    assert_eq!(parsed, expected);
}

#[test]
fn preserves_object_member_order() {
    let parsed = parse("{\"z\": 1, \"a\": 2}").unwrap();
    let expected = Value::Object(vec![
        ("z".to_string(), Value::Number(1.0)),
        ("a".to_string(), Value::Number(2.0)),
    ]);
    assert_eq!(parsed, expected);
}

#[test]
fn rejects_trailing_characters() {
    assert!(parse("null null").is_err());
    assert!(parse("[1, 2] x").is_err());
}

#[test]
fn rejects_malformed_input() {
    assert!(parse("").is_err());
    assert!(parse("[1, 2").is_err());
    assert!(parse("{\"a\": }").is_err());
    assert!(parse("\"unterminated").is_err());
    assert!(parse("{\"a\" 1}").is_err());
}

Proposed solution

# JSON parser to a subset of JSON

Implementing a parser for a subset of JSON:

```json
{
    "null",
    "true",
    "false",
    "array",
    "object",
    "string",
    "nil",
    "struct",
    "enum",
    "tuple",
    "union",
    "ref",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",
    "let",

Errors (stderr)

no code extracted from response