Home/ Questions/Q 8433869
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-10T06:30:20+00:00

I’ve been reading about F# 3.0 type providers (e.g. here ) and it seems

  • 0

I’ve been reading about F# 3.0 type providers (e.g. here) and it seems that they are based on a kind of compile-time code generation. In that respect I was wondering how they compare against Lisp macros. It would seem that both F# 3.0 type providers and Lisp macros allow user code to execute at compile time and introduce new types available to the compiler. Can anyone shed some light on the issue and nuances involved?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    There is some overlap between F# type providers and meta-programming techniques from other languages, but I agree with Daniel that they do not have much in common. F# has some other meta-programming techniques like quotations that are perhaps closer to LISP macros.

    In particular:

    • LISP macros are typically used to transform expressions (you can take a LISP expression and either interpret it or transform it and then execute it). Note that the transformation takes a LISP expression as an input – on the other hand, type providers can only take very limited parameters (strings, integers).

    • Quotations are more similar. They can be used to process F# expression – you can treat a piece of F# code as data and interpret it or transform it. The transformation takes (a sub-set of) an F# expression, but it typically does not execute it.

    • Type providers are used purely to generate types. Since LISP is dynamically typed, this is not really a problem that you’d have in LISP. However, it is a sort of code-generation (a form of metaprogramming that you can certainly do in LISP).

    • 0