Json.Pull

beginArray

beginArray : () ->{Pull} ()Source

Consumes an array’s opening bracket, failing if the next token is another.

beginObject

beginObject : () ->{Pull} ()Source

Consumes an object’s opening brace, failing if the next token is another.

decodeValue

decodeValue : Decode a => () ->{Pull} aSource

Decodes the next value as a: starts scanValue at the cursor, runs any suspended work, and publishes the final position. Calling it for a child runs that child’s one parser.

fail

fail : String ->{Pull} aSource

Fails with message at the current path, positioned at the start of the token most recently returned by next or peek or consumed by a decoded operation, or at the current position once the cursor moved on another way.

import Bytes
import Json.Pull
import Reader
import Result exposing (Result(..))

failure : Result Json.Pull.Error Int
failure =
    Reader.withBytes (Bytes.fromString "[true]") { reader ->
        Json.Pull.withReader reader {
            Json.Pull.beginArray ()
            ignore (Json.Pull.peek ())
            Json.Pull.fail "no booleans"
        }
    }

Result.mapError { e -> (e.message, e.offset) } failure == Err ("no booleans", 1)

mapScan

mapScan : (a -> b) -> Result (() ->{Pull} ScanStep a) (a, Scan) -> Result (() ->{Pull} ScanStep b) (b, Scan)Source

Transforms a scan’s value, buffered or resumed alike.

numberText

numberText : Number -> StringSource

The number’s lexeme as written.

readValue

readValue : () ->{Pull} ValueSource

Consumes the next value and builds its generic tree.

runScan

runScan : Result (() ->{Pull} ScanStep a) (a, Scan) ->{Pull} (a, Scan)Source

Runs suspended scan work until it answers a value and position, or fails with a JSON or source failure.

scanFromPull

scanFromPull : Scan -> (() ->{Pull} a) -> Result (() ->{Pull} ScanStep a) (a, Scan)Source

A deferred action runs only after the pure scan reaches a boundary or a token/custom decoder. It publishes that prefix and returns its new window.

skipValue

skipValue : () ->{Pull} ()Source

Consumes and validates the next value without building it.

import Bytes
import Json.Pull
import Reader
import Result exposing (Result(..))

rest =
    Reader.withBytes (Bytes.fromString "[{\"a\": [1, 2]}, 3]") { reader ->
        Json.Pull.withReader reader {
            Json.Pull.beginArray ()
            Json.Pull.skipValue ()
            ignore (Json.Pull.nextElement False)
            Json.Pull.next ()
        }
    }

rest == Ok (Json.Pull.NumberToken "3")

withIndex

withIndex : Int -> (() ->{Pull} a) ->{Pull} aSource

Runs action with element index added to the path of errors raised inside it.

withKey

withKey : String -> (() ->{Pull} a) ->{Pull} aSource

Runs action with key added to the path of errors raised inside it.

withReader

withReader : Reader e -> (() ->{Pull} a) ->{e} Result Error aSource

Runs action with the Pull effect over a byte reader, decoding UTF-8. On return, normally or with Err, the reader is positioned after the last token scanned, peek lookahead included, as it is when an unrelated effect leaves the scope; inside, it may lag behind, so advance it only after the scope.

import Bytes
import Json.Pull
import Reader
import Result exposing (Result(..))

tokens = Reader.withBytes (Bytes.fromString "[1]") { reader -> Json.Pull.withReader reader { [Json.Pull.next (), Json.Pull.peek (), Json.Pull.next (), Json.Pull.next ()] } }

tokens == Ok [Json.Pull.BeginArray, Json.Pull.NumberToken "1", Json.Pull.NumberToken "1", Json.Pull.EndArray]

withTextReader

withTextReader : Reader e -> (() ->{Pull} a) ->{e} Result Error aSource

withReader over a text reader, whose encoding the caller chose.