Back to Questions
5.4k
views8
comments
Ideas for usage of the F# macro system
f#macromacrosround table

Those of you who follow, have probably seen my latest blog post Text-based Macro System for F#. While the macro system is not yet production-ready (mostly because I was the only debugger until now, and could only find the bugs I had thought of checking for), I think that the next step for it would be some use by other people.

The reasons for this "idea gathering" are as following:

  1. Seeing what F# macros are good for, thus showing it is worth spending time on.
  2. Possibly starting new community projects for F#, using the macro system (I heard several people saying "I would gladly do X, but without macros in F# it would be hard", last of them I remember is Richard Minerich on an F# reflection library.
  3. Brainstorming is always good :)

To keep things easy for archivists and future visitors, I'll keep this list of ideas updated as the discussion goes:

  • LaTeX literals - I've used this to convince several scientists that F# is great. Shown by me in the original blog post.
  • XML/HTML literals - there is a simple version presented in the original blog post, but this could also be used to HTML templates for F# web development (WebSharper, Pit, ASP.NET etc.).
  • Joinads - it is possible to implement joinads using macros!
  • Type classes - several people mentioned it might be easier with macros.
  • Higher-order generics/higher-order modules - several people mentioned it might be easier with macros.
  • Lenses auto-generation.
  • Links-like formlets. See Mauricio's comment.
  • Automating serialization/de-serialization code, instead of using Reflection. See Rick Minerich's comment.
  • "One obvious idea would be implementing further metaprogramming capabilities, say defining macros for dealing with external DSL syntax.". See Adam's comment
.

Now the question is how to make this extension portable across different/future versions of F#.

By on 12/14/2011 2:27 PM ()

My latest thought on implementing higher-order modules in an ML-like fashion can be found here.

By on 12/10/2011 6:32 AM ()

One obvious idea would be implementing further metaprogramming capabilities, say defining macros for dealing with external DSL syntax. Although the string to string nature of macros is definitely a limiting factor, this could make some intriguing use of DSLs.

Here is a slightly contrived example using an imaginary graph DSL called "Neureka" (inspired by some earlier work from a long time ago):

1
2
3
4
5
6
7
8
9
10
11

let G = LoadDirectedWeightedGraphFromFile @"..."
let C1, C2 = RandomNodeFrom G, RandomNodeFrom G

let pathFromC1ToC2 =
   Neureka {{
      find Path in G(V, E) where
      first(Path)=C1 and last(Path)=C2
      and Path is valid in G(V, E)
      and cost(Path) is minimized
   }}
...
By on 12/9/2011 2:54 PM ()

You could easily create a base macro which does basic preliminary lexing, calls another sub-macro with the token list, gets back an AST (even F# quotations) then prints them to text.

The advantage of text-to-text is that it adds the possibility for text-macros and allows different macros to be written with a different lexer/AST pair, because different macros would need different features.

By on 12/9/2011 11:07 PM ()

The number one thing I'd like to use them for is as a faster replacement for Reflection. For example, one common thing we do for serialization is recursively reflect over a record tree and fill it in from a file. Would be great if we could generate the mechanics of this at runtime instead.

By on 12/7/2011 1:40 PM ()
  • Lenses
  • Links-like formlets (example). It looks like XML literals but desugaring it is actually much more complex. Links has a version of this implemented with camlp4, which I started translating to a Nemerle macro but never finished :(
By on 12/7/2011 1:00 PM ()

Forgot the lenses! Knew I should have went over the email logs :)

Will look into Links, seems pretty cool on the first glance, though I think it should be pretty much designed from scratch to fit the "F# feel". Yesod and WebSharper both shared some characteristics with Links.

By on 12/7/2011 1:17 PM ()

I don't know about any other web library/framework with formlets sugar. Not even Yesod has it AFAIK (see how the formlet is defined separately from HTML/Hamlet in this example using just regular applicative functor operators).
An F# macro providing syntax sugar for formlets could desugar either into WebSharper formlets or FsFormlets

By on 12/7/2011 1:47 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper