Safe Haskell	None
Language	Haskell2010

Saison

Contents

Types
Conversion to/from Value
Parsing
- Record

Description

Stream Aeson, fruity, spicy, well carbonated.

Saison represents JSON document as well-formed token stream. This approach is potentially faster than document model (i.e. representing document as an ADT) used in aeson. Also the approach is more flexible, as more structure is preseved, especially key-value pairs in records are not ordered.

Saison is proof-of-concept package at the moment.

The tokens aren't exactly as in JSON, but in similar grammar. There are no commas, but each item in arrays is prepended with zero-width marker (to differentiate from the end):

VALUE   = LITERAL | TEXT | NUMBER | "[" ARRAY | "{" RECORD
LITERAL = "null"
        | "true"
        | "false"
TEXT    = ...
NUMBER  = ...
ARRAY   = ITEM VALUE ARRAY
        | "]"
ITEM    = epsilon
RECORD  = KEY VALUE RECORD
        | "}"
KEY     = TEXT

Haskell types reflect this grammar:

VALUE is Tokens
LITERAL is Lit
ARRAY is TkArray
RECORD is TkRecord.

Synopsis

data Tokens k e
- = TkLit !Lit k
- | TkText !Text k
- | TkNumber !Scientific k
- | TkArrayOpen (TkArray k e)
- | TkRecordOpen (TkRecord k e)
- | TkErr e
data Lit
- = LitNull
- | LitTrue
- | LitFalse
data TkArray k e
- = TkItem (Tokens (TkArray k e) e)
- | TkArrayEnd k
- | TkArrayErr e
data TkRecord k e
- = TkPair !Text (Tokens (TkRecord k e) e)
- | TkRecordEnd k
- | TkRecordErr e
toValue :: Tokens b Void -> Value
fromValue :: Value -> Tokens () a
eitherDecodeStrict :: FromTokens a => ByteString -> Either String a
class FromTokens a where
- fromTokens :: Tokens k String -> Result String k a
- fromTokensList :: Tokens k String -> Result String k [a]
skipValue :: Tokens k e -> Result e k ()
data RecordParser a
runRecordParser :: RecordParser a -> Tokens k String -> Result String k a
requiredField :: Text -> (forall k. Tokens k String -> Result String k a) -> RecordParser a
optionalField :: Text -> (forall k. Tokens k String -> Result String k a) -> RecordParser (Maybe a)
skippedField :: Text -> RecordParser (a -> a)
(<.:>) :: FromTokens a => RecordParser (a -> b) -> Text -> RecordParser b
(<.:?>) :: FromTokens a => RecordParser (Maybe a -> b) -> Text -> RecordParser b

Types

data Tokens k e Source #

Tokens.

Note: Lit exists to make Tokens have only 6 constructors. This may or may not have impact on performance.

TODO: should number (and text) be represented by raw ByteString, instead of Scientific (and Text)? With some guarantees that those are well-formed, so conversion to Scientific and Text will succeed.

Constructors

TkLit !Lit k
TkText !Text k
TkNumber !Scientific k
TkArrayOpen (TkArray k e)
TkRecordOpen (TkRecord k e)
TkErr e

Instances

AsError Tokens Source #
Instance details Defined in Saison.Decoding.Tokens Methods tkErr :: e -> Tokens k e Source #
(Eq k, Eq e) => Eq (Tokens k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods (==) :: Tokens k e -> Tokens k e -> Bool # (/=) :: Tokens k e -> Tokens k e -> Bool #
(Show k, Show e) => Show (Tokens k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods showsPrec :: Int -> Tokens k e -> ShowS # show :: Tokens k e -> String # showList :: [Tokens k e] -> ShowS #

data Lit Source #

Literals. null, true, false.

Constructors

LitNull
LitTrue
LitFalse

Instances

Eq Lit Source #
Instance details Defined in Saison.Decoding.Tokens Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Show Lit Source #
Instance details Defined in Saison.Decoding.Tokens Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #

data TkArray k e Source #

Array tokens.

Constructors

TkItem (Tokens (TkArray k e) e)
TkArrayEnd k
TkArrayErr e

Instances

AsError TkArray Source #
Instance details Defined in Saison.Decoding.Tokens Methods tkErr :: e -> TkArray k e Source #
(Eq k, Eq e) => Eq (TkArray k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods (==) :: TkArray k e -> TkArray k e -> Bool # (/=) :: TkArray k e -> TkArray k e -> Bool #
(Show k, Show e) => Show (TkArray k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods showsPrec :: Int -> TkArray k e -> ShowS # show :: TkArray k e -> String # showList :: [TkArray k e] -> ShowS #

data TkRecord k e Source #

Record tokens.

Constructors

TkPair !Text (Tokens (TkRecord k e) e)
TkRecordEnd k
TkRecordErr e

Instances

AsError TkRecord Source #
Instance details Defined in Saison.Decoding.Tokens Methods tkErr :: e -> TkRecord k e Source #
(Eq k, Eq e) => Eq (TkRecord k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods (==) :: TkRecord k e -> TkRecord k e -> Bool # (/=) :: TkRecord k e -> TkRecord k e -> Bool #
(Show k, Show e) => Show (TkRecord k e) Source #
Instance details Defined in Saison.Decoding.Tokens Methods showsPrec :: Int -> TkRecord k e -> ShowS # show :: TkRecord k e -> String # showList :: [TkRecord k e] -> ShowS #

Conversion to/from Value

toValue :: Tokens b Void -> Value Source #

Convert Tokens to aeson's Value.

This is an evidence that Tokens encoding is sound.

fromValue :: Value -> Tokens () a Source #

Opposite direction of toValue.

Parsing

eitherDecodeStrict :: FromTokens a => ByteString -> Either String a Source #

Parse a value from strict ByteString.

class FromTokens a where Source #

Minimal complete definition

fromTokens

Methods

fromTokens :: Tokens k String -> Result String k a Source #

fromTokensList :: Tokens k String -> Result String k [a] Source #

Instances

FromTokens Char Source #
Instance details Defined in Saison.Decoding.Class Methods fromTokens :: Tokens k String -> Result String k Char Source # fromTokensList :: Tokens k String -> Result String k [Char] Source #
FromTokens Void Source #
Instance details Defined in Saison.Decoding.Class Methods fromTokens :: Tokens k String -> Result String k Void Source # fromTokensList :: Tokens k String -> Result String k [Void] Source #
FromTokens Text Source #
Instance details Defined in Saison.Decoding.Class Methods fromTokens :: Tokens k String -> Result String k Text Source # fromTokensList :: Tokens k String -> Result String k [Text] Source #
FromTokens Value Source #
Instance details Defined in Saison.Decoding.Class Methods fromTokens :: Tokens k String -> Result String k Value Source # fromTokensList :: Tokens k String -> Result String k [Value] Source #
FromTokens Laureate Source #
Instance details Defined in Saison.Decoding.Examples Methods fromTokens :: Tokens k String -> Result String k Laureate Source # fromTokensList :: Tokens k String -> Result String k [Laureate] Source #
FromTokens SomeValue Source #
Instance details Defined in Saison.Decoding.Examples Methods fromTokens :: Tokens k String -> Result String k SomeValue Source # fromTokensList :: Tokens k String -> Result String k [SomeValue] Source #
FromTokens a => FromTokens [a] Source #
Instance details Defined in Saison.Decoding.Class Methods fromTokens :: Tokens k String -> Result String k [a] Source # fromTokensList :: Tokens k String -> Result String k [[a]] Source #
FromTokens a => FromTokens (Laureates a) Source #	This instance differs from `aeson`'s, here we require that object has exactly one key: `"laureates"`. TODO: currently this instance is written manually. Separate ways to interpret record: lenient and strict.
Instance details Defined in Saison.Decoding.Examples Methods fromTokens :: Tokens k String -> Result String k (Laureates a) Source # fromTokensList :: Tokens k String -> Result String k [Laureates a] Source #

skipValue Source #

Arguments

:: Tokens k e	tokens
-> Result e k ()

Skip value. Useful sometimes.

Record

data RecordParser a Source #

Instances

Functor RecordParser Source #
Instance details Defined in Saison.Decoding.Record Methods fmap :: (a -> b) -> RecordParser a -> RecordParser b # (<$) :: a -> RecordParser b -> RecordParser a #
Applicative RecordParser Source #
Instance details Defined in Saison.Decoding.Record Methods pure :: a -> RecordParser a # (<>) :: RecordParser (a -> b) -> RecordParser a -> RecordParser b # liftA2 :: (a -> b -> c) -> RecordParser a -> RecordParser b -> RecordParser c # (>) :: RecordParser a -> RecordParser b -> RecordParser b # (<*) :: RecordParser a -> RecordParser b -> RecordParser a #

runRecordParser :: RecordParser a -> Tokens k String -> Result String k a Source #

requiredField :: Text -> (forall k. Tokens k String -> Result String k a) -> RecordParser a Source #

optionalField :: Text -> (forall k. Tokens k String -> Result String k a) -> RecordParser (Maybe a) Source #

skippedField :: Text -> RecordParser (a -> a) Source #

(<.:>) :: FromTokens a => RecordParser (a -> b) -> Text -> RecordParser b infixl 4 Source #

requiredField using FromTokens parser.

(<.:?>) :: FromTokens a => RecordParser (Maybe a -> b) -> Text -> RecordParser b infixl 4 Source #