Foreign.Generic.Class
- Package
- purescript-foreign-generic
- Repository
- paf31/purescript-foreign-generic
#Options Source
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
).
#SumEncoding Source
data SumEncoding
The encoding of sum types for your type.
TaggedObject
s 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 }
#defaultOptions Source
defaultOptions :: Options
Default decoding/encoding options:
- Represent sum types as records with
tag
andcontents
fields - Unwrap single arguments
- Don't unwrap single constructors
- Use the constructor names as-is
- Use the field names as-is
#Decode Source
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
Instances
#Encode Source
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
Instances
#DecodeWithOptions Source
class DecodeWithOptions a where
When deriving En
/Decode
instances using Generic
, we want
the Options
object to apply to the outermost record type(s)
under the data constructors.
For this reason, we cannot use En
/Decode
directly when we
reach an Argument
during generic traversal of a type, because it
might be a record type. Instead, we need to peel off any record
type(s) and apply the appropriate Options
before we can delegate
to En
/Decode
, which can bake in its own Options
.
Members
decodeWithOptions :: Options -> Foreign -> F a
Instances
(RowToList r rl, DecodeRecord r rl) => DecodeWithOptions (Record r)
(Decode a) => DecodeWithOptions a
#EncodeWithOptions Source
class EncodeWithOptions a where
See the comment on DecodeWithOptions
.
Members
encodeWithOptions :: Options -> a -> Foreign
Instances
(RowToList r rl, EncodeRecord r rl) => EncodeWithOptions (Record r)
(Encode a) => EncodeWithOptions a
#DecodeRecord Source
class DecodeRecord r rl | rl -> r where
Members
Instances
DecodeRecord () Nil
(Cons l a r_ r, DecodeRecord r_ rl_, IsSymbol l, DecodeWithOptions a, Lacks l r_) => DecodeRecord r (Cons l a rl_)
#EncodeRecord Source
class EncodeRecord r rl | rl -> r where
Members
Instances
EncodeRecord () Nil
(Cons l a r_ r, EncodeRecord r_ rl_, IsSymbol l, EncodeWithOptions a) => EncodeRecord r (Cons l a rl_)
#GenericDecode Source
class GenericDecode a where
Members
decodeOpts :: Options -> Foreign -> F a
Instances
GenericDecode NoConstructors
(IsSymbol name, GenericDecodeArgs rep, GenericCountArgs rep) => GenericDecode (Constructor name rep)
(GenericDecode a, GenericDecode b) => GenericDecode (Sum a b)
#GenericEncode Source
class GenericEncode a where
Members
encodeOpts :: Options -> a -> Foreign
Instances
GenericEncode NoConstructors
(IsSymbol name, GenericEncodeArgs rep) => GenericEncode (Constructor name rep)
(GenericEncode a, GenericEncode b) => GenericEncode (Sum a b)
#GenericDecodeArgs Source
class GenericDecodeArgs a where
Members
decodeArgs :: Options -> Int -> List Foreign -> F { next :: Int, rest :: List Foreign, result :: a }
Instances
GenericDecodeArgs NoArguments
(DecodeWithOptions a) => GenericDecodeArgs (Argument a)
(GenericDecodeArgs a, GenericDecodeArgs b) => GenericDecodeArgs (Product a b)
#GenericEncodeArgs Source
class GenericEncodeArgs a where
Members
encodeArgs :: Options -> a -> List Foreign
Instances
GenericEncodeArgs NoArguments
(EncodeWithOptions a) => GenericEncodeArgs (Argument a)
(GenericEncodeArgs a, GenericEncodeArgs b) => GenericEncodeArgs (Product a b)