extending functions in F# - f#

Question

in the following code the executeProg function is executing the program instructions list.
it's execute the program with "PUSH ax, POP bx ..etc".
//Execute a program as a list of operations. Note how pc is incremented
//so any jump instruction must be written carefully.
let mutable executeProg = fun (program:operation list) ->
pc <- 0
fault <- false
while not(fault) && pc<program.Length do
let instruction = program.[pc];
execute instruction
pc <- pc+1
// end of while by indentation
if not(fault) then printfn "top of stack holds value %d" (RAM.[sp-1]);
what I'm trying to do is: modify the executeProg so it would do the following:
push ax
pop bx --> replace with single instruction mov ax bx
push ax
pop ax --> eliminate altogether
mov ax bx
mov bx ax --> mov ax bx
My question is, how would I implement a new executeProg modullary without change the original one?
my code is as the following:
let rec optimize = fun newProgram program ->
let mutable newProgram = newProgram
match program with
| (PUSH(Reg(a)):: POP(Reg(b)) :: r) when String.Equals(a,b) ->
optimize newProgram r
| (PUSH(Reg(a)):: POP(Reg(b)) :: r) ->
newProgram <- newProgram # [MOV(Reg(a),Reg(b))]
optimize newProgram r
| (PUSH(Imm(a)):: POP(Imm(x)):: r) when a = x ->
optimize newProgram r
| (MOV(Reg(a), Reg(b)) :: MOV(Reg(b), Reg(a)) :: r) ->
newProgram <- newProgram # [MOV(Reg(a),Reg(b))]
optimize newProgram r
| (a::r) ->
newProgram <- newProgram # [a]
optimize newProgram r
| [] -> newProgram
I'm new to F# language and I'm wondering if my syntax is correct.
Would be grateful for any help
Thank you.

Answer 1

I think that you don't need to have a mutable function. Perhaps you can change the design to use immutable, composable structures that will allow you to add new functionality to your solution.
I played with the problem a bit and here's what I got.
Declare types that you will use in the program:
type Register =
| AX
| BX
type Operand =
| Register of Register
| Int of int
type Command =
| MOV of Register * Operand
| PUSH of Operand
| POP of Operand
type FnBinaryOp = Register -> Operand -> Command
type FnUnaryOp = Operand -> Command
type Program = Command list
//two helper functions to save some typing
let i n = Int n
let r n = Register n
//helper functions to clarify the declaration syntax
let mov:FnBinaryOp =
fun reg op -> MOV (reg, op)
let push: FnUnaryOp = fun op -> PUSH (op)
let pop: FnUnaryOp = fun op -> POP (op)
Implement your optimization method - it returns the modified instruction list. This is where the code inefficiencies are rectified.
///optimize the program - remove cancelling stack commands, simplify MOV commands
let optimize (program:Program) =
let rec recOptimize stack prog =
match prog with
| PUSH (Register r1)::POP (Register r2)::xs when r1 = r2 -> //push ax; pop ax => nop
xs |> recOptimize stack
| PUSH (Register r1)::POP (Register r2)::xs when r1 <> r2 -> //push ax; pop bx => move ax bx
xs |> recOptimize (MOV(r1, Register(r2))::stack)
| PUSH (Int i1)::POP (Int i2)::xs when i1 = i2 -> //push 3; pop 3 => nop
xs |> recOptimize stack
| ((MOV (r1, Register r2 )) as op1)::((MOV (r3, Register r4 )) as op2)::xs when r1 = r4 && r2 = r3 -> //move ax bx; move bx ax => move ax bx
xs |> recOptimize (op1::stack)
| ((MOV (r1, Register r2 )) as op1)::((MOV (r3, Register r4 )) as op2)::xs when r1 = r3 && r2 = r4 -> //move ax bx; move ax bx => move ax bx
xs |> recOptimize (op1::stack)
| op::xs -> //all other cases - pass through
xs |> recOptimize (op::stack)
| [] -> stack
program
|> recOptimize []
Implement the actual execution of your program (not implemented here)
let runProgram (program:Program) =
let rec run stack prog =
[]
program |> run []
And this is how you can invoke this:
let program:Program = [
mov AX (r BX)
push (r BX)
pop (r BX)
mov AX (r BX)
]
program
|> optimize
|> runProgram
If you need to add new functionality to the optimization step, you can just replace the optimize element of the composite call.
You can run multiple passes of optimize to cover for cases where certain operations become 'paired' and you want to optimize them as well.
program
|> optimize
|> optimize
|> runProgram
Here is a few tests:
[<Fact>]
let ``push 42; pop 42 => nop`` () =
let program:Program = [
push (i 42)
pop (i 42)
]
let optimized = program |> optimize
//should be reduced to empty list
Assert.Empty(optimized)
[<Fact>]
let ``push ax; pop ax => nop`` () =
let program:Program = [
push (r AX)
pop (r AX)
]
let optimized = program |> optimize
//should be reduced to empty list
Assert.Empty(optimized)
[<Fact>]
let ``push ax; pop bx => move ax bx`` () =
let program:Program = [
push (r AX)
pop (r BX)
]
let optimized = program |> optimize
//should be reduced to a single element list mov ax bx
let expected = MOV( AX, (r BX))
let op = optimized.Head
Assert.Equal(1, optimized.Length)
Assert.Equal(expected, op)
[<Fact>]
let ``move ax bx; move bx ax => move ax bx`` () =
let program:Program = [
mov AX (r BX)
mov BX (r AX)
]
let optimized = program |> optimize
//should be reduced to a single element list mov ax bx
let expected = MOV( AX, (r BX))
let op = optimized.Head
Assert.Equal(1, optimized.Length)
Assert.Equal(expected, op)
[<Fact>]
let ``run optimize on program`` () =
let program:Program = [
mov AX (r BX)
push (r BX)
pop (r BX)
mov AX (r BX)
]
let optimized = program
|> optimize
|> optimize
|> optimize
//should be reduced to a single element list mov ax bx
let expected = MOV( AX, (r BX))
let op = optimized.Head
Assert.Equal(1, optimized.Length)
Assert.Equal(expected, op)