blocks|key|2964714|text|Haskell的自省机制是Template+Haskell，它支持编译时元编程，当与llvm结合使用时，可以提供运行时元编程工具。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2964715|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/Template_Haskell|1|http://hackage.haskell.org/package/llvm^0|D|G|0|16|4|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Haskell's introspection mechanism is <a href="http://www.haskell.org/haskellwiki/Template_Haskell" rel="noreferrer">Template Haskell</a>, which supports compile time metaprogramming, and when combined with e.g. <a href="http://hackage.haskell.org/package/llvm" rel="noreferrer">llvm</a>, provides runtime metaprogramming facilities.

blocks|key|2964790|text|Ocaml有：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2964791|在Ocaml中操作Ocaml具体语法树的|2964792|Camlp4。用于在运行时生成本机代码的全规模多阶段programming.|unordered-list-item|offset|length|2964793|Ocamljit的维护实现是Camlp5.|2964794|MetaOCaml，但我不认为它是recently.|2964795|Ocaml-Java为Camlp4虚拟机编译Ocaml代码的维护。我不知道有没有好的反射capabilities.|2964796|2964797|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Camlp4|1|http://pauillac.inria.fr/~ddr/camlp5/|2|http://www.metaocaml.org/|3|http://ocamljava.x9c.fr/^0|0|0|0|6|0|0|E|6|1|0|0|9|2|0|0|A|3|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@$G|16|H|17|1|18]]|A|$]]|$1|I|3|J|5|F|7|19|8|@]|9|@$G|1A|H|1B|1|1C]]|A|$]]|$1|K|3|L|5|F|7|1D|8|@]|9|@$G|1E|H|1F|1|1G]]|A|$]]|$1|M|3|N|5|F|7|1H|8|@]|9|@$G|1I|H|1J|1|1K]]|A|$]]|$1|O|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|Y]]|Z|$5|S|T|U|A|$V|10]]|11|$5|S|T|U|A|$V|12]]]]

Ocaml has:

<ul>
<li><a href="http://en.wikipedia.org/wiki/Camlp4" rel="noreferrer">Camlp4</a> to manipulate Ocaml concrete syntax trees in Ocaml. The maintained implementation of Camlp4 is <a href="http://pauillac.inria.fr/~ddr/camlp5/" rel="noreferrer">Camlp5</a>.</li>
<li><a href="http://www.metaocaml.org/" rel="noreferrer">MetaOCaml</a> for full-scale multi-stage programming.</li>
<li>Ocamljit to generate native code at run time, but I don't think it's been maintained recently.</li>
<li><a href="http://ocamljava.x9c.fr/" rel="noreferrer">Ocaml-Java</a> to compile Ocaml code for the Java virtual machine. I don't know if there are nice reflection capabilities.</li>
</ul>

blocks|key|999414|text|不是一个真正的答案，但也请注意F#+Quotations特性和library，以了解更多homoiconicity内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|999415|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd233212.aspx|1|http://msdn.microsoft.com/en-us/library/ee370558.aspx|2|http://en.wikipedia.org/wiki/Homoiconic^0|I|A|0|V|7|1|18|D|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

Not really an answer, but note also the F# <a href="http://msdn.microsoft.com/en-us/library/dd233212.aspx" rel="nofollow noreferrer">Quotations</a> feature and <a href="http://msdn.microsoft.com/en-us/library/ee370558.aspx" rel="nofollow noreferrer">library</a>, for more <a href="http://en.wikipedia.org/wiki/Homoiconic" rel="nofollow noreferrer">homoiconicity</a> stuff.

blocks|key|1001770|text|您可以查看Racket的typed+variant+(以前称为PLT+Scheme)。它保留了Scheme的大部分语法简单性，但提供了静态类型系统。由于球拍是一种方案，元编程是课程的一部分，运行时可以通过a+JIT的方式发出本机代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1001771|entityMap|0|LINK|mutability|MUTABLE|url|http://racket-lang.org/|1|http://docs.racket-lang.org/ts-guide/index.html|2|http://docs.racket-lang.org/guide/performance.html^0|5|6|0|C|D|1|2U|5|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

You might check out the <a href="http://docs.racket-lang.org/ts-guide/index.html" rel="noreferrer">typed variant</a> of <a href="http://racket-lang.org/" rel="noreferrer">Racket</a> (previously known as PLT Scheme). It retains most of the syntactic simplicity of Scheme, but provides a static type system. Since Racket is a Scheme, metaprogramming is par for the course, and the runtime can emit native code by way of <a href="http://docs.racket-lang.org/guide/performance.html" rel="noreferrer">a JIT</a>.

blocks|key|1744554|text|Haskell方法更接近于解析源代码。Haskell平台包括一个完整的源代码解析器，或者您可以使用GHC+API以这种方式获得访问权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744555|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The Haskell approach would be more along the lines of parsing the source. The Haskell Platform includes a complete source parser, or you can use the GHC API to get access that way.

blocks|key|1744428|text|我还会看看Scala或Clojure，它们附带了所有为Java开发的库。如果库不存在，您将永远不需要担心。但更重要的是，这些语言提供了与Java中相同的反射(或更强大的类型)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744429|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'd also look at Scala or Clojure which come with them all the libraries that have been developed for Java. You'll never need to worry if a library does not exist. But more to the point of your question, these languages give you the same reflection (or more powerful types) that you will find within Java.

blocks|key|1744574|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744575|我正在设计一个东西(函数的机器学习)，它最好需要一种函数式编程语言，也需要自省，特别是能够以某种易于处理的格式检查程序自己的代码，最好也能够在运行时编译机器生成的代码，我想知道用什么语言编写最好。当然，Lisp具有强大的自省功能，但静态类型语言也有优势；我正在考虑的是：|blockquote|1744576|1744577|1744578|你不能像普通的解释器或编译器一样解析源代码吗？为什么你需要自省？|1744579|1744580|+F#+-+.Net平台在这里有一个很好的故事，你可以在运行时读取字节码，也可以发出字节码并编译它；我假设从F#访问这些工具没有问题。|1744581|1744582|1744583|F#有一个基本的引用机制，但您只能引用某些表达式，而不能引用其他类型的代码，尤其是类型定义。此外，它的评估机制比真正的编译慢了几个数量级，所以它基本上是完全无用的。您可以使用反射来分析类型定义，但它仍然是非常初级的。|1744584|你可以读取字节码，但它已经被编译了，所以很多信息和结构都丢失了。|1744585|F#也有词法分析和解析技术(最著名的是fslex、fsyacc和FParsec)，但它不如OCaml的成熟。|1744586|1744587|+Haskell，Ocaml+-这些有没有类似的功能，通过字节码或解析树？|1744588|1744589|1744590|Haskell有模板Haskell，但我从来没有听说过有人使用它(放弃软件？)。|1744591|OCaml有自己的Camlp4宏系统，也有一些人在使用它，但它是poorly+documented。|offset|length|1744592|至于词法分析和解析，Haskell有几个库(最著名的是Parsec)，OCaml有many+libraries。|1744593|1744594|有没有其他我也应该看的语言？|1744595|1744596|1744597|像Mathematica这样的术语重写语言将是一个显而易见的选择，因为它们使得操纵代码变得微不足道。Pure语言可能会引起您的兴趣。|1744598|您还可以考虑使用MetaOCaml的运行时编译功能。|1744599|entityMap|0|LINK|mutability|MUTABLE|url|http://brion.inria.fr/gallium/index.php/Camlp4|1|http://caml.inria.fr/cgi-bin/hump.en.cgi?sort=0&browse=96|2|http://code.google.com/p/pure-lang/^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|W|H|0|0|15|E|1|0|0|0|0|0|1E|4|2|0|0^^$0|@$1|2|3|-4|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1S|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1T|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1U|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|1V|7|@]|8|@]|9|$]]|$1|I|3|J|4|C|6|1W|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|1X|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|1Y|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|1Z|7|@]|8|@]|9|$]]|$1|O|3|P|4|5|6|20|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|21|7|@]|8|@]|9|$]]|$1|S|3|-4|4|5|6|22|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|23|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|24|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|25|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|26|7|@]|8|@]|9|$]]|$1|Z|3|10|4|5|6|27|7|@]|8|@$11|28|12|29|1|2A]]|9|$]]|$1|13|3|14|4|5|6|2B|7|@]|8|@$11|2C|12|2D|1|2E]]|9|$]]|$1|15|3|-4|4|5|6|2F|7|@]|8|@]|9|$]]|$1|16|3|17|4|C|6|2G|7|@]|8|@]|9|$]]|$1|18|3|-4|4|5|6|2H|7|@]|8|@]|9|$]]|$1|19|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]|$1|1A|3|1B|4|5|6|2J|7|@]|8|@$11|2K|12|2L|1|2M]]|9|$]]|$1|1C|3|1D|4|5|6|2N|7|@]|8|@]|9|$]]|$1|1E|3|-4|4|5|6|2O|7|@]|8|@]|9|$]]]|1F|$1G|$4|1H|1I|1J|9|$1K|1L]]|1M|$4|1H|1I|1J|9|$1K|1N]]|1O|$4|1H|1I|1J|9|$1K|1P]]]]

<blockquote>
 I'm sketching a design of something (machine learning of functions) that will preferably want a functional programming language, and also introspection, specifically the ability to examine the program's own code in some nicely tractable format, and preferably also the ability to get machine generated code compiled at runtime, and I'm wondering what's the best language to write it in. Lisp of course has strong introspection capabilities, but the statically typed languages also have advantages; the ones I'm considering are:
</blockquote>

Can you not just parse the source code like an ordinary interpreter or compiler? Why do you need introspection?

<blockquote>
 F# - the .Net platform has a good story here, you can read byte code at run time and also emit byte code and get it compiled; I assume there's no problem accessing these facilities from F#.
</blockquote>

F# has a rudimentary quotation mechanism but you can only quote some expressions and not other kinds of code, most notably type definitions. Also, its evaluation mechanism is orders of magnitude slower than genuine compilation so it is basically completely useless. You can use reflection to analyze type definitions but, again, it is quite rudimentary.

You can read byte code but that has been compiled so a lot of information and structure has been lost.

F# also has lexing and parsing technology (most notably fslex, fsyacc and FParsec) but it is not as mature as OCaml's.

<blockquote>
 Haskell, Ocaml - do these have similar facilities, either via byte code or parse tree?
</blockquote>

Haskell has Template Haskell but I've never heard of anyone using it (abandonware?).

OCaml has its Camlp4 macro system and a few people do use it but it is <a href="http://brion.inria.fr/gallium/index.php/Camlp4" rel="nofollow">poorly documented</a>.

As for lexing and parsing, Haskell has a few libraries (most notably Parsec) and OCaml has <a href="http://caml.inria.fr/cgi-bin/hump.en.cgi?sort=0&amp;browse=96" rel="nofollow">many libraries</a>.

<blockquote>
 Are there other languages I should also be looking at?
</blockquote>

Term rewrite languages like Mathematica would be an obvious choice because they make it trivial to manipulate code. The <a href="http://code.google.com/p/pure-lang/" rel="nofollow">Pure</a> language might be of interest.

You might also consider MetaOCaml for its run-time compilation capabilities.

I'm sketching a design of something (machine learning of functions) that will preferably want a functional programming language, and also introspection, specifically the ability to examine the program's own code in some nicely tractable format, and preferably also the ability to get machine generated code compiled at runtime, and I'm wondering what's the best language to write it in. Lisp of course has strong introspection capabilities, but the statically typed languages also have advantages; the ones I'm considering are:

F# - the .Net platform has a good story here, you can read byte code at run time and also emit byte code and get it compiled; I assume there's no problem accessing these facilities from F#.

Haskell, Ocaml - do these have similar facilities, either via byte code or parse tree?

Are there other languages I should also be looking at?

Functional programming languages introspection

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我正在勾画一种设计(函数的机器学习)，它最好是一种函数式编程语言，也需要自省，特别是能够以某种易于处理的格式检查程序自己的代码，最好还有在运行时编译机器生成的代码的能力，我想知道用什么语言编写它最好。当然，Lisp具有强大的自省功能，但静态类型语言也有优势；我正在考虑的是：F# - .Net平台在这里有一个很好的故事，你可以在运行时读取字节码，也可以发出字节码并编译它；我假设从F#访问这些工具是没

问函数式编程语言自省
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问函数式编程语言自省EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问函数式编程语言自省
EN