blocks|key|1269814|text|无论如何，我认为在OCaml中找到的预处理器解决方案(如sexplib、binprot和json-wheel等)是非常好的(我认为人们使用模板Haskell可以做非常类似的事情)。它比反射效率高得多，而且还可以自然地调优到单个类型。如果您不喜欢给定类型foo的自动生成的序列化程序，您可以编写自己的序列化程序，它非常适合包含foo作为组件的类型的自动生成的序列化程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269815|唯一的缺点是，您需要学习camlp4才能自己编写其中的一个。但是，一旦您将构建系统设置为使用预处理器，使用它们就非常简单。这就像在类型定义的末尾添加with+sexp一样简单：|offset|length|style|CODE|1269816|type+t+=+{+foo:+int;+bar:+float+}
with+sexp|code-block|syntax|javascript|1269817|现在，您有了序列化程序。|1269818|entityMap^0|0|22|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

For what it's worth, I think the pre-processor solution found in OCaml (as exemplified by sexplib, binprot and json-wheel among others) is pretty great (and I think people do very similar things with Template Haskell). It's far more efficient than reflection, and can also be tuned to individual types in a natural way. If you don't like the auto-generated serializer for a given type foo, you can always just write your own, and it fits beautifully into the auto-generated serializers for types that include foo as a component.

The only downside is that you need to learn camlp4 to write one of these for yourself. But using them is quite easy, once you get your build-system set up to use the preprocessor. It's as simple as adding <code>with sexp</code> to the end of a type definition:

<pre><code>type t = { foo: int; bar: float }
with sexp
</code></pre>

and now you have your serializer.

blocks|key|1055097|text|我的理解是，在Haskell中序列化和反序列化的最简单方法是从Read和Show派生。这很简单，并且不能完全满足您的需求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1055098|但是，似乎有HXT和Text.JSON可以满足您的需求。|1055099|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/HXT/Conversion_of_Haskell_data_from/to_XML|1|http://hackage.haskell.org/packages/archive/json/0.4.3/doc/html/Text-JSON.html^0|V|4|10|4|0|6|3|0|A|9|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

My understanding is that the simplest way to serialize and deserialize in Haskell is to derive from <code>Read</code> and <code>Show</code>. This is simple and isn't fullfilling your requirements.

However there are <a href="http://www.haskell.org/haskellwiki/HXT/Conversion_of_Haskell_data_from/to_XML" rel="nofollow noreferrer">HXT</a> and <a href="http://hackage.haskell.org/packages/archive/json/0.4.3/doc/html/Text-JSON.html" rel="nofollow noreferrer">Text.JSON</a> which seem to provide what you need.

blocks|key|1269910|text|通常的方法是使用Data.Binary。这提供了基本的序列化功能。数据类型的二进制实例很容易编写，并且可以很容易地从较小的单元中构建。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1269911|如果你想自动生成实例，那么你可以使用模板Haskell。我不知道有什么包可以做到这一点，但如果已经存在一个包，我也不会感到惊讶。|1269912|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/binary-0.5.0.2^0|8|B|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

The usual approach is to employ <a href="http://hackage.haskell.org/package/binary-0.5.0.2" rel="nofollow noreferrer">Data.Binary</a>. This provides the basic serialisation capability. Binary instances for data types are easy to write and can easily be built out of smaller units.

If you want to generate the instances automatically then you can use Template Haskell. I don't know of any package to do this, but I wouldn't be surprised if one already exists.

One of the huge benefits in languages that have some sort of reflection/introspecition is that objects can be automatically constructed from a variety of sources.

For example, in Java I can use the same objects for persisting to a db (with Hibernate), serializing to XML (with JAXB), and serializing to JSON (json-lib). You can do the same in Ruby and Python also usually following some simple rules for properties or annotations for Java.

Thus I don't need lots "Domain Transfer Objects". I can concentrate on the domain I am working in.

It seems in very strict FP like Haskell and Ocaml this is not possible. 
Particularly Haskell. The only thing I have seen is doing some sort of preprocessing or meta-programming (ocaml). Is it just accepted that you have to do all the transformations from the bottom upwards?

In other words you have to do lots of boring work to turn a data type in haskell into a JSON/XML/DB Row object and back again into a data object.

How do I do automatic data serialization of data objects?

数据库

Python

JSON

Java

在具有某种类型的反射/自定义的语言中，一个巨大的好处是可以从各种来源自动构造对象。例如，在Java中，我可以使用相同的对象来持久化数据库(使用Hibernate)、序列化到XML (使用JAXB)和序列化到JSON (json-lib)。您可以在Ruby和Python中执行相同的操作，通常还需要遵循一些简单的Java属...

问如何实现数据对象的自动数据序列化？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何实现数据对象的自动数据序列化？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何实现数据对象的自动数据序列化？
EN