Foreign.Generic

genericDecode :: forall a rep. Generic a rep => GenericDecode rep => Options -> Foreign -> F a

Read a value which has a Generic type.

genericEncode :: forall a rep. Generic a rep => GenericEncode rep => Options -> a -> Foreign

Generate a Foreign value compatible with the genericDecode function.

decodeJSON :: forall a. Decode a => String -> F a

Decode a JSON string using a Decode instance.

encodeJSON :: forall a. Encode a => a -> String

Encode a JSON string using an Encode instance.

genericDecodeJSON :: forall a rep. Generic a rep => GenericDecode rep => Options -> String -> F a

Read a value which has a Generic type from a JSON String

genericEncodeJSON :: forall a rep. Generic a rep => GenericEncode rep => Options -> a -> String

Write a value which has a Generic type as a JSON String

data ForeignError

A type for foreign type errors

Constructors

• ForeignError String
• TypeMismatch String String
• ErrorAtIndex Int ForeignError
• ErrorAtProperty String ForeignError

Instances

• Eq ForeignError
• Ord ForeignError
• Show ForeignError

data Foreign

A type for foreign data.

Foreign data is data from any external unknown or unreliable source, for which it cannot be guaranteed that the runtime representation conforms to that of any particular type.

Suitable applications of Foreign are

• To represent responses from web services
• To integrate with external JavaScript libraries.

type F = Except MultipleErrors

While this alias is not deprecated, it is recommended that one use Except (NonEmptyList ForeignError) directly for all future usages rather than this type alias.

An error monad, used in this library to encode possible failures when dealing with foreign data.

The Alt instance for Except allows us to accumulate errors, unlike Either, which preserves only the last error.

data SumEncoding

The encoding of sum types for your type. TaggedObjects will be encoded in the form { [tagFieldName]: "ConstructorTag", [contentsFieldName]: "Contents"}. constructorTagTransform can be provided to transform the constructor tag to a form you use, e.g. toLower/toUpper.

Constructors

• TaggedObject { constructorTagTransform :: String -> String, contentsFieldName :: String, tagFieldName :: String }

type Options = { fieldTransform :: String -> String, sumEncoding :: SumEncoding, unwrapSingleArguments :: Boolean, unwrapSingleConstructors :: Boolean }

Encoding/Decoding options which can be used to customize Decode and Encode instances which are derived via Generic (see genericEncode and genericDecode).

class Decode a  where

The Decode class is used to generate decoding functions of the form Foreign -> F a using generics-rep deriving.

First, derive Generic for your data:

import Data.Generic.Rep

data MyType = MyType ...

derive instance genericMyType :: Generic MyType _

You can then use the genericDecode and genericDecodeJSON functions to decode your foreign/JSON-encoded data.

Members

• decode :: Foreign -> F a

Instances

• Decode Void
• Decode Unit
• Decode Foreign
• Decode String
• Decode Char
• Decode Boolean
• Decode Number
• Decode Int
• (Decode a, Decode b) => Decode (Either a b)
• (Decode a, Decode b) => Decode (Tuple a b)
• (Decode a) => Decode (Identity a)
• (Decode a) => Decode (Array a)
• (Decode a, Ord a) => Decode (Set a)
• (Decode a) => Decode (Maybe a)
• (Decode v) => Decode (Object v)
• (RowToList r rl, DecodeRecord r rl) => Decode (Record r)
• (Decode a) => Decode (Poly a)

class Encode a  where

The Encode class is used to generate encoding functions of the form a -> Foreign using generics-rep deriving.

First, derive Generic for your data:

import Data.Generic.Rep

data MyType = MyType ...

derive instance genericMyType :: Generic MyType _

You can then use the genericEncode and genericEncodeJSON functions to encode your data as JSON.

Members

• encode :: a -> Foreign

Instances

• Encode Void
• Encode Unit
• Encode Foreign
• Encode String
• Encode Char
• Encode Boolean
• Encode Number
• Encode Int
• (Encode a) => Encode (Identity a)
• (Encode a) => Encode (Array a)
• (Encode a, Ord a) => Encode (Set a)
• (Encode a) => Encode (Maybe a)
• (Encode a, Encode b) => Encode (Either a b)
• (Encode a, Encode b) => Encode (Tuple a b)
• (Encode v) => Encode (Object v)
• (RowToList r rl, EncodeRecord r rl) => Encode (Record r)
• (Encode a) => Encode (Poly a)

class GenericDecode a 

Instances

• GenericDecode NoConstructors
• (IsSymbol name, GenericDecodeArgs rep, GenericCountArgs rep) => GenericDecode (Constructor name rep)
• (GenericDecode a, GenericDecode b) => GenericDecode (Sum a b)

class GenericEncode a 

Instances

• GenericEncode NoConstructors
• (IsSymbol name, GenericEncodeArgs rep) => GenericEncode (Constructor name rep)
• (GenericEncode a, GenericEncode b) => GenericEncode (Sum a b)

defaultOptions :: Options

Default decoding/encoding options:

• Represent sum types as records with tag and contents fields
• Unwrap single arguments
• Don't unwrap single constructors
• Use the constructor names as-is
• Use the field names as-is