I'm working on making Fluent NHibernate look nicer with F#. Part of this is trying to reduce the tons of "|> ignore" that are littered around my mappings.

Just to suggest a different angle: have you considered turning the fluent interface into a CPS like functional interface?

The fluent interface works very succintly for the most part, syntax wise. It's still wierd as it's changing global state and ignoring return values, but whatever looks pretty for this works :).

I considered extending obj with an Ignore member, but that's sorta invasive.

I think that CPS style would just add overhead from the added lambdas and whatnot, no?

Hi,

Yes, the fact it's NHibernate isn't too related actually. It's more for "fluent" interfaces in general. But in this case, what Fluent NHibernate does is lets you subclass a "ClassMap<T>", then call special world-changing methods in the constructor. I documented my first pass at this with F# here: [link:www.atrevido.net]

From their sample "first project", an example mapping looks like this:

1
2
3
4
5
6
7
8
9
10
11

 public class ProductMap : ClassMap {   
  public ProductMap() {   
    Id(x => x.Id);   
    Map(x => x.Name);   
    Map(x => x.Price);   
    HasManyToMany(x => x.StoresStockedIn)   
      .Cascade.All()   
      .Inverse()   
      .WithTableName("StoreProduct");   
  }   
}  

To write this in F# (after adding my own base class "QClassMap" with overloads to deal with quotations), I end up with:

1
2
3
4
5
6
7
8
9

 type ProductMap() as m = inherit QClassMap() do
    let x = Unchecked.defaultof // allows direct values instead of "fun x -> x"
    m.Id <@ x.Id @> |> ignore
    m.Map <@ x.Name @> |> ignore
    m.Map <@ x.Price @> |> ignore
    (m.HasManyToMany <@ seq x.StoresStockedIn @>)
        .Cascade.All()
        .Inverse()
        .WithTableName("StoreProduct") |> ignore

While this is pretty good, most of the times, Id, Map, and some others (like Reference) have their return values discarded (but not always). By creating "overloads" that return unit, I can avoid some ignores:

1
2
3
4
5
6
7
8
9

type ProductMap() as m = inherit QClassMap() do
    let x = m.DefaultX
    m.IdI <@ x.Id @>
    m.MapI <@ x.Name @>
    m.MapI <@ x.Price @>
    (m.HasManyToMany <@ seq x.StoresStockedIn @>)
        .Cascade.All()
        .Inverse()
        .WithTableName("StoreProduct") |> ignore

My question is: "Is this worth it?" Are there prettier ways to accomplish this? Having methods like "IdI" doesn't fit completely right with me, but it ends up in shorter code with slightly less noise.