Back to Questions
2.0k
views1
comment
Solving A Problem In F#/Functional Programming
f#functionalclasses

I have a situation that I am trying to solve in a functional way. Specifically in an F# way.

In C# I have something like this (assume this is backed by a db that has person table and an address table with a fk pointing to the person):

[Transaction]
public void DeletePersonAndAddress(id personid)
{
var personDao = new PersonDao();
personDao.deleteAddressByPersonId(personid);
personDao.deletePerson(personid);
}

The transaction attribute is actually an aspect. This code happens to use spring.net. The attribute causes the runtime to wrap the method in a transactional scope. This transactional scope is injected into the classes that are called by the fact that the PersonDao class would derive from a known library class (AdoSupport or some such). Methods within PersonDao use member variables to access the transaction (and db connection) to do their work.

In an ideal world I could simply do this in F#:

let DeletePersonAndAddress personid =
transaction {
do personid |> deleteAddressByPersonId |> deletePerson
}

For the sake of argument let's assume the two delete methods are monoids of type int -> int. ie. assume they compose as I have shown. The problem here is that the delete methods need access to state of their surrounding monad, specifically the transaction. As far as I understand, this is not allowed. Second, the delete methods would have to have the type allong the lines of transaction -> int -> int in order to compose. I can't really think of a way to do this, maybe currying?

In any case, I thought I'd throw this out there to some of you smart people to see if there is a solution to this type of problem. I am fairly new to functional programming and this is a problem I have yet to be able to solve. I'm not sure if I am being limited by my imperative thinking or this is simply a hard problem to solve functionally. A nice solution to this kind of problem would seem to be a good thing to have.

Thanks for any help or thoughts.

.

Here are some random thoughts...

'transaction' here is like a State monad, in that it's about state in the ambient environment. If you are not familiar with a State monad, you might read it and check out

[link:cs.hubfs.net]

Then I think you can model your code as

1
2
3
4
5
6
7
8
9
10
11
12

 

transaction {

    let p = new PersonDao()

    do! deleteAddressByPersonId(p, personid)

    do! deletePerson(p, personid)

}

where the monadic operations grab the 'current transaction' out of the state monad. You might also consider authoring something along the lines of

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 

let (|!>) mx mf =
    m {
        let! x = mx
        let! r = mf x
        return r
    }
    
m {
    let! x = Blah()
    let! y = f(x)
    let! z = g(y)
    return z
}

Blah() |!> f |!> g

for pipeline-composition syntax in the monad 'm'. I haven't thought all the way through that, but hopefully those are some starter ideas.

By on 5/22/2009 5:53 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