Link Search Menu Expand Document

JSON overview

Various functions to aid in working with JSON.

Added in v0.1.0


Table of contents


utils

JSONString (type alias)

Newtype representing stringified JSON.

Signature

export type JSONString = Newtype<{ readonly JSONString: unique symbol }, string>
newtype JSONString = string

Added in v0.5.0

parse

Parse a string as JSON. The Json type on the right side comes from fp-ts and is a union of all possible parsed types.

Signature

export declare const parse: <E>(f: (e: SyntaxError) => E) => (x: string) => Either<E, Json>
parse :: (SyntaxError -> e) -> string -> Either e Json

Example

import { parse } from 'fp-ts-std/JSON'
import * as E from 'fp-ts/Either'
import { constant } from 'fp-ts/function'

const f = parse(constant('e'))

const valid = '"abc"'
const invalid = 'abc'

assert.deepStrictEqual(f(valid), E.right('abc'))
assert.deepStrictEqual(f(invalid), E.left('e'))

Added in v0.1.0

parseO

Parse a string as JSON, returning an Option.

Signature

export declare const parseO: (stringified: string) => Option<unknown>
parseO :: string -> Option unknown

Example

import { parseO } from 'fp-ts-std/JSON'
import * as O from 'fp-ts/Option'

const valid = '"abc"'
const invalid = 'abc'

assert.deepStrictEqual(parseO(valid), O.some('abc'))
assert.deepStrictEqual(parseO(invalid), O.none)

Added in v0.1.0

stringify

Stringify some arbitrary data.

Signature

export declare const stringify: <E>(f: (e: TypeError) => E) => (x: unknown) => Either<E, JSONString>
stringify :: (TypeError -> e) -> unknown -> Either e JSONString

Example

import { stringify } from 'fp-ts-std/JSON'
import * as E from 'fp-ts/Either'
import { constant } from 'fp-ts/function'

const f = stringify(constant('e'))

const valid = 'abc'
const invalid = () => {}

assert.deepStrictEqual(f(valid), E.right('"abc"'))
assert.deepStrictEqual(f(invalid), E.left('e'))

Added in v0.1.0

stringifyO

Stringify some arbitrary data, returning an Option.

Signature

export declare const stringifyO: (data: unknown) => Option<JSONString>
stringifyO :: unknown -> Option JSONString

Example

import { stringifyO } from 'fp-ts-std/JSON'
import * as O from 'fp-ts/Option'

const valid = 'abc'
const invalid = () => {}

assert.deepStrictEqual(stringifyO(valid), O.some('"abc"'))
assert.deepStrictEqual(stringifyO(invalid), O.none)

Added in v0.1.0

stringifyPrimitive

Stringify a primitive value with no possibility of failure.

Signature

export declare const stringifyPrimitive: (x: string | number | boolean | null) => JSONString
stringifyPrimitive :: string | number | boolean | null -> JSONString

Example

import { stringifyPrimitive } from 'fp-ts-std/JSON'

assert.strictEqual(stringifyPrimitive('abc'), '"abc"')

Added in v0.1.0

unJSONString

Unwrap a JSONString newtype back to its underlying string representation.

Signature

export declare const unJSONString: (s: JSONString) => string
unJSONString :: JSONString -> string

Added in v0.6.0

unstringify

Parse a string as JSON. This is safe provided there have been no shenanigans with the JSONString newtype.

Signature

export declare const unstringify: (x: JSONString) => unknown
unstringify :: JSONString -> unknown

Example

import { unstringify, stringifyPrimitive } from 'fp-ts-std/JSON'
import { flow } from 'fp-ts/function'

const f = flow(stringifyPrimitive, unstringify)

assert.strictEqual(f('abc'), 'abc')

Added in v0.5.0