`json` Module

The json module provides functions for working with JSON data, including seamless integration with Harneet's map and array types.

Functions

`Marshal(value)`

Converts a Harneet value to a JSON string. Supports strings, numbers, booleans, arrays, and maps.

Parameters: - value: The value to convert (string, integer, boolean, None, array, or map).

Returns: - (string, error): The JSON string representation of the value.

Examples:

Basic types:

Marshal Basic Types

package main
import fmt
import json

var data = ["apple", "banana", "cherry"]
var jsonString, err = json.Marshal(data)
if err != None {
    fmt.Println("Marshal error:", err)
} else {
    fmt.Println(jsonString) // Output: ["apple","banana","cherry"]
}

Maps to JSON objects:

Marshal Map to JSON

package main
import fmt
import json

var user = {"name": "Alice", "age": 25, "active": true}
var jsonResult, err = json.Marshal(user)
if err != None {
    fmt.Println("Marshal error:", err)
} else {
    fmt.Println(jsonResult) // Output: {"age":25,"active":true,"name":"Alice"}
}

Nested structures:

Marshal Nested Structures

package main
import fmt
import json

var config = {"database": {"host": "localhost", "port": 5432}, "debug": true}
var jsonConfig, err = json.Marshal(config)
if err != None {
    fmt.Println("Marshal error:", err)
} else {
    fmt.Println(jsonConfig) // Output: {"database":{"host":"localhost","port":5432},"debug":true}
}

`Unmarshal(json_string)`

Parses a JSON string into a Harneet value. JSON objects become Harneet maps, JSON arrays become Harneet arrays.

Parameters: - json_string: The JSON string to parse.

Returns: - (any, error): The parsed Harneet value (string, integer, boolean, None, array, or map).

Examples:

JSON arrays to Harneet arrays:

Unmarshal JSON Array

package main
import fmt
import json

var jsonString = "[\"apple\",\"banana\",\"cherry\"]"
var parsed, parseErr = json.Unmarshal(jsonString)
if parseErr != None {
    fmt.Println("Parse error:", parseErr)
} else {
    fmt.Println(parsed) // Output: [apple, banana, cherry]
}

JSON objects to Harneet maps:

Unmarshal JSON Object

package main
import fmt
import json

var jsonUser = "{\"name\": \"Alice\", \"age\": 25, \"active\": true}"
var user, err = json.Unmarshal(jsonUser)
if err != None {
    fmt.Println("Parse error:", err)
} else {
    fmt.Printf("User: %s\n", user) // Output: User: {name: Alice, age: 25, active: true}
    // Access map values
    // var name = user["name"]  // Returns "Alice"
    // var age = user["age"]    // Returns 25
}

Nested JSON structures:

Unmarshal Nested JSON

package main
import fmt
import json

var complexJson = "{\"users\": [{\"name\": \"Alice\"}, {\"name\": \"Bob\"}], \"meta\": {\"count\": 2}}"
var data, err = json.Unmarshal(complexJson)
if err != None {
    fmt.Println("Parse error:", err)
} else {
    fmt.Printf("Data: %s\n", data)
    // Access nested structures
    // var users = data["users"]     // Array of user maps
    // var meta = data["meta"]       // Meta information map
    // var count = meta["count"]     // Returns 2
}

`Valid(json_string)`

Checks if a string is a valid JSON.

Parameters: - json_string: The string to check.

Returns: - (boolean, error): true if the string is valid JSON, false otherwise.

`Indent(json, prefix, indent)`

Formats a JSON string with indentation.

Parameters: - json: The JSON string to format. - prefix: The prefix for each line. - indent: The indentation string.

Returns: - (string, error): The indented JSON string.

JSON-Maps Integration

The json module provides seamless integration with Harneet's map and array types, making JSON processing natural and efficient.

Type Mapping

JSON Type	Harneet Type	Example
`object`	`map`	`{"key": "value"}` → `{key: value}`
`array`	`array`	`[1, 2, 3]` → `[1, 2, 3]`
`string`	`string`	`"hello"` → `"hello"`
`number`	`int` or `float64`	`42` → `42`, `3.14` → `3.14`
`boolean`	`bool`	`true` → `true`
`null`	`None`	`null` → `None`

Round-trip Conversion

JSON data can be converted to Harneet types and back without data loss:

Round-Trip Conversion

package main
import fmt
import json

// Original Harneet data
var original = {"name": "Alice", "scores": [95, 87, 92], "active": true}

// Convert to JSON
var jsonStr, err1 = json.Marshal(original)
if err1 != None {
    fmt.Println("Marshal error:", err1)
    return
}

fmt.Printf("JSON: %s\n", jsonStr)

// Convert back to Harneet
var restored, err2 = json.Unmarshal(jsonStr)
if err2 != None {
    fmt.Println("Unmarshal error:", err2)
    return
}

fmt.Printf("Restored: %s\n", restored)
// Output: Restored: {name: Alice, scores: [95, 87, 92], active: true}

Working with API Responses

JSON APIs can be easily processed using Harneet's map operations:

JSON API Processing

package main
import fmt
import json

// Simulate API response
var apiResponse = "{\"users\": [{\"id\": 1, \"name\": \"Alice\"}, {\"id\": 2, \"name\": \"Bob\"}], \"total\": 2}"

var data, err = json.Unmarshal(apiResponse)
if err != None {
    fmt.Println("API parse error:", err)
    return
}

// Access API data using map operations
// var users = data["users"]
// var total = data["total"]
// var firstUser = users[0]
// var firstName = firstUser["name"]

fmt.Printf("API Data: %s\n", data)

Configuration Management

JSON configuration files can be loaded as Harneet maps:

JSON Config Files

package main
import fmt
import json

var configJson = "{\"database\": {\"host\": \"localhost\", \"port\": 5432}, \"cache\": {\"ttl\": 300, \"enabled\": true}}"

var config, err = json.Unmarshal(configJson)
if err != None {
    fmt.Println("Config parse error:", err)
    return
}

// Access configuration values
// var dbHost = config["database"]["host"]
// var cacheEnabled = config["cache"]["enabled"]

fmt.Printf("Configuration: %s\n", config)

Error Handling

The JSON module provides comprehensive error handling for invalid data:

JSON Error Handling

package main
import fmt
import json

// Invalid JSON
var invalidJson = "{\"name\": \"Alice\", \"age\": }"
var data, err = json.Unmarshal(invalidJson)
if err != None {
    fmt.Printf("JSON Error: %s\n", err)
} else {
    fmt.Printf("Data: %s\n", data)
}

// Map with non-string keys (not JSON compatible)
var invalidMap = {42: "number key", "string": "string key"}
var jsonStr, marshalErr = json.Marshal(invalidMap)
if marshalErr != None {
    fmt.Printf("Marshal Error: %s\n", marshalErr)
} else {
    fmt.Printf("JSON: %s\n", jsonStr)
}

json Module