1.0k
views4
comments

Traditionally, methods operate by changing the "*this" object (example in C#)

class Number
{
  public int num;

  public void Incr() { num = num + 1; }
}

Alternatively, one could do (example in F#)

1
2
3

type Number =
  { num: int }
  with member x.Incr() = { x where num = x.num + 1 }

A problem with the second way, which works without side-effects, is that it is a bit tedious to use with nested objects. Compare (using the first case in C#):

top.sub.Incr();

with (in F#):

1
2

let sub2 = top.sub.Incr()
let top2 = { top with sub = sub2 }

The problem only gets worse as the level of nesting increases. Is there a nice solution to this problem?

Hi,
I'll try to give you more an answer that shows a more fundamental change that you can do when writing code in the functional style. I'm not sure what's some more concrete problem that you're concerned with, so I'll use a general example. However, it should answer your question about easy modificiation of nested data structures in functional programming.

In functional programming, you'll often define some data structure and then implement processing functions for working with it. For example, let's use a simple expressions:

 
type Expr =
 | Add of Expr * Expr
 | Num of int

let e = Add(Num(10), Add(Num(100), Num(1)))

The value 'e' is an expression and one of its deeply nested values is the value 'Num(100)'. Once we have the data structre, we can write a higher order function that allows us to modify any nested exprssions:

 
let rec modifyNestedNums f e = 
  match e with 
  | Add(a, b) -> 
      let a = modifyNestedNums f a
      let b = modifyNestedNums f b
      Add(a, b) 
  | Num(n) -> f(n)

This allows you to specify function that changes values of "Num" nodes in the data structure. Now we can write the following code to change only the "Num(100)" node without affecting anything else:

1
2
3

 
> e |> modifyNestedNums (fun n -> if n > 50 then Num(n/2) else Num(n)) ;;
val it : Expr = Add (Num 10,Add (Num 50,Num 1))

So, my point is that functional design gives a different answer than object oriented style in situations like this. It of course depends on the particular problem you're solving. In F#, you can choose between those two styles, so both of them make sometimes sense, however I think the functional way makes the code more readable once you're used to it.

By Tomas Petricek on 12/21/2008 5:01 PM (permalink)

Kenny55: I would like to avoid the use of mutable data structures.

tomasp: My problem involves modeling cars and their four wheels. It must be possible to distinguish between e.g. the left front wheel, the right front wheel...
My modeling, which I think is typical of OO, makes heavy use of "the", as in "the left front wheel of car C1".
The example you give, using expressions, ends in a different category of genericity, I would say. As such, it would be possible to solve my problem the way you describe, but I fear it may end up being excessively generic. Thanks anyway for suggesting a new approach to my problem, I will think more about it.

By Johann Deneux on 12/22/2008 2:56 AM (permalink)

Replying to myself, here is some pseudo-code that's decent, I think, but still not quite good enough:

(* Examples of types *)

type Vector3 = Vector3 of double []
    static member X =
        Array.init 3 (fun i -> if (i = 0) then 1.0 else 0.0) |> Vector3
    static member Add((Vector3 u), (Vector3 v)) =
        Array.zip u v |> Array.map (fun (x, y) -> x + y) |> Vector3


type WheelPart =
    { model_name : string;
      object_name : string;
      transform : Matrix4;
      center : Vector3 }


type VehicleParts =
    { front_left_wheel : WheelPart;
      front_right_wheel : WheelPart; }
    static member Empty = ...


(* Functions to emulate the "obj -> subobj -> method (arg)" notation in C++ *)

let id x = x

let top vehicle =
    id, vehicle
     
let selWheelFR (newVehicle, vehicle) =
    (fun new_wheel -> newVehicle { vehicle with front_right_wheel = new_wheel }), vehicle.front_right_wheel

let selWheelCenter (newWheel, wheel : WheelPart) =
    (fun new_center -> newWheel { wheel with center = new_center }), wheel.center
    
let (-->) (update, v) f =
    update (f v)
                    
let vehicle = VehicleParts.Empty

let vehicle2 = (top vehicle |> selWheelFR) --> (fun w -> { w with model_name = "name"})
let vehicle3 = (top vehicle2 |> selWheelFR |> selWheelCenter) --> (fun c -> Vector3.Add(c, Vector3.X))
let vehicle4 = (top vehicle3 |> selWheelFR |> selWheelCenter) --> (fun _ -> Vector3.Zero)

Silly question: is there a way to specify the respective priorities of operators? I don't like the parentheses before -->

Smarter question: I'm lazy and I would like a convenient (ideally fully automatic) way to define the sel* functions. Is that possible?

By Johann Deneux on 12/22/2008 11:00 AM (permalink)

type Number =

     val mutable num : int

     member this.Incr() = this.num /- this.num + 1

     new() = {num = 0}

does this solve it?

(Notice that / should be replaced with lesser than sign, but for some reason the same sign removes the rest of the line)

By Kenny55 on 12/21/2008 11:20 AM (permalink)

Topic tags

Built with WebSharper

Home

Answers

Events

Courses

Groups and Conferences

Blogs

Jobs

Developers

Topic tags