Elm Language Coding Error - variable-assignment

Question

type Expr = Const Float | Var String| Add Expr Expr| Mult Expr Expr
list = [3,1,4]
polyX : List Float -> Expr
polyX coeffs = polyHelper <| map Const <| coeffs
polyHelper: List Expr -> Expr
polyHelper e = case e of
[x] -> x
(x::xs) -> Add x(Mult(Var "x")(polyHelper xs))
[] -> Const 1
type Instr = LoadImmediate RegisterNumber --put value here
RegisterValue --the value
| Addition RegisterNumber --put result here
RegisterNumber --first thing to add
RegisterNumber --first thing to multiply
| Multiply RegisterNumber --put result here
RegisterNumber --first thing to multiply
RegisterNumber --second thing to multiply
type RegisterNumber = Int
type RegisterValue = Float
expr2Code : Expr -> List Instr
expr2Code expr = e2C 1 expr
e2C result expr = case expr of
Const x -> ((LoadImmediate(result+2))x)
Add expr1 expr2 -> (Addition result result (result+1))::(e2C result expr2)++(e2C result expr1)
Mult expr1 expr2 -> (Mult result result(result+1))::(e2C result expr2)++(e2C result expr1)
Var x -> []
I am having difficulty with an assignment.
Question:
Assume that the only variable you will see is x and it is already in register 2. Arrange for the result to arrive to be in register 1 at the end of the computation, and use registers 3 and 4 for other values, as needed. Write the helper function e2C to complete.
My T.A says that the code I have right now will compile, but it will not solve for the question.
Can anyone tell me how to fix the code so it will solve for the question?

Answer 1

Getting it to compile
Well, you're TA is wrong, that code snippet does not compile. Here's a compiling version:
type Expr
= Const Float
| Var String
| Add Expr Expr
| Mult Expr Expr
type Instr
= LoadImmediate RegisterNumber --put value here
RegisterValue --the value
| Addition RegisterNumber --put result here
RegisterNumber --first thing to add
RegisterNumber --first thing to multiply
| Multiply RegisterNumber --put result here
RegisterNumber --first thing to multiply
RegisterNumber --second thing to multiply
type alias RegisterNumber
= Int
type alias RegisterValue
= Float
list : List Float
list =
[3,1,4]
polyX : List Float -> Expr
polyX coeffs =
polyHelper <| List.map Const <| coeffs
polyHelper: List Expr -> Expr
polyHelper e =
case e of
[x] ->
x
(x::xs) ->
Add x (Mult (Var "x") (polyHelper xs))
[] ->
Const 1
expr2Code : Expr -> List Instr
expr2Code expr =
e2C 1 expr
e2C : RegisterNumber -> Expr -> List Instr
e2C result expr =
case expr of
Const x ->
[LoadImmediate (result+2) x]
Add expr1 expr2 ->
Addition result result (result+1)
:: e2C result expr2 ++ e2C result expr1
Mult expr1 expr2 ->
Multiply result result (result+1)
:: e2C result expr2 ++ e2C result expr1
Var x ->
[]
I've formatted the code more in accordance with the style guide. I found the following problems before your code compiled:
polyX used an unqualified map function, but there are no imports, so you should use the qualified List.map.
The types RegisterNumber and RegisterValue are type aliases. Use type alias for those, otherwise you're defining constructors Int and Float for completely independent types RegisterNumber and RegisterValue instead of relating those to the types Int andFloat`.
The Const branch in e2C wasn't returning a list, but the other branches of the case were.
The Mult branch in e2C was using Mult instead of Multiply for the result, which is an Expr, not an Instr.
Getting it to work
DISCLAIMER: Check you school/course regulations on FRAUD. In my experience, students are expected to submit only solutions that they wrote themselves. High-level discussions about solutions are usually OK, copying code is most likely NOT OK. This answer may go into too much detail according to your school's fraud regulations. Citing your sources is not always enough!
Given the three instructions that you can do, it's not easy to move a result from one register into another. That'll require bogus instructions like [LoadImmediate freeRegister 0, Addition moveToThisRegister MoveFromThisRegister freeRegister]. So you can't elegantly create an elaborate compiler, and you probably don't have to, given that you're only asked to complete helper function e2C.
So we're going for the easy, non-general solution. You'll want to make some assumptions about the Expr that you get in. Note that polyX only generates additions and multiplications that have a somehow constant (Const or Var) left-hand side. This is the property we'll exploit.
So if you do the right-hand side expressions first, and give that expression the same result register that you're given, then you still have both free registers (3 and 4) for your left-hand side. Use only one of them consistently, then do the operation between the result register and the chosen free register.
Moving the value of variable x to a different register is kind of ugly when there is no move operation. But it's fairly general, so let's use the left-over free register to add 0 to the value of variable x and save that value to the register that we're supposed to put the result in. This gives you the following implementation:
registerOfX : RegisterNumber
registerOfX = 2
freeRegister1 : RegisterNumber
freeRegister1 = 3
freeRegister2 : RegisterNumber
freeRegister2 = 4
e2C : RegisterNumber -> Expr -> List Instr
e2C resultRegister expr =
case expr of
Const value ->
[LoadImmediate resultRegister value]
Add expr1 expr2 ->
e2C resultRegister expr2
++ e2C freeRegister1 expr1
++ [Addition resultRegister freeRegister1 resultRegister]
Mult expr1 expr2 ->
e2C resultRegister expr2
++ e2C freeRegister1 expr1
++ [Multiply resultRegister freeRegister1 resultRegister]
Var "x" ->
[LoadImmediate freeRegister2 0, Addition resultRegister registerOfX freeRegister2]
Var _ ->
"Cannot handle "
++ toString expr
++ ", we only know of "
++ toString (Var "x")
|> Debug.crash
One final note, since this is already a long answer. You'll see that this code results in some redundant LoadImmediate 4 0 instructions. You can add a signal instruction for it to the front of the list by doing something like LoadImmediate freeRegister2 0 :: case expr of .... Then you can move variable x to a register in one instruction. Any further minimisation of the instructions will require extra steps that are best done in further helper functions, or you'll need to make the code less general by directly matching on Mult (Var "x") expr2 and use the register of variable x directly.