#lang plai racket multiplier function

Question

I am working on a project to get us used to the plai-typed language for use in a programming languages course. I have been stuck on one question that's really bugging me (finished all the rest with no problem). We are to take this datatype definition :

(define-type Tree
[leaf (val number?)]
[node (val number?)
(left Tree?)
(right Tree? ) ] ) 

and then "Implement the function 'scaled', which takes a tree and returns a tree that has the same shape, but with all the values multiplied by the given scale.

Example: (scaled (node -5 (leaf 6) (leaf -7)) 2) should produce (node -10 (leaf 12) (leaf -14))"

So basically I just need to muliply all those values by a given value, in this example, 2.

Here is what I have so far after trying out different ways:

(define (scaled [ t Tree?] [n  number?] )  
(type-case Tree t  
[leaf (val) val] 
[node (val left right) ( * val (scaled left) (scaled right)  n  ) ] ) )    

I based it on previous code that I created for the other parts of the assignment that I got right. The issue is, it multiplies all the numbers and results "succesfully" with the solution of 420 instead of mutlplying each value individually. I know this has to do with my placement of 'n' but I tried so many different ways with no luck. If anyone has any helpful hints/tips/solution it would be greatly appreciated.

Thanks!

Answer 1

The way to think about the problem is not by going down to lower levels of implementation but up to a level where we can think about what scaled is. The issue isn't figuring out where to put n. It's figuring out what scaled is supposed to do.

Whatever else it does, it needs to return a tree.

; DefType F1 : Any -> Tree
(define (f1 x)
  (leaf 42))

The next most important thing is it needs to take a tree as input.

; DefType F2 : Tree -> Tree
(define (f2 [t Tree?])
  (leaf 42))

There's isomorphism between the input and output that must be addressed next. The structure of the output tree needs to match the structure of the input tree.

; DefType F3 : Tree -> Tree
(define (f3 [t Tree?])
  t)

This gets us what we want but at the expense of quality from a functional programming standpoint because f3 returns a reference to the input rather than a value derived from the input. The function needs to return a new output value with the same structure as the input value. To duplicate the structure, the function has to return a node when passed a node and a leaf when passed a leaf.

; DefType F4 : Tree -> Tree
(define (f4 [t Tree?])
  (type-case Tree t
    [leaf (val) (leaf val)]
    [node (val left right)
       (node val (f4 left)(f4 right))]))

Now that the types are sorted out, it's time to deal with transforming the input tree into the output tree. That requires moving up a level rather than down. The place to start is by rewriting f4.

; DefType F5 : Tree -> Tree
(define (f5 [t Tree?])
  (type-case Tree t
    [leaf (val) (leaf (id val))]
    [node (val left right)
      (node (id val) (f5 left)(f5 right))]))

Important, but not very interesting. Replacing id with arbitrary functions seems like more fun. So much fun that it's probably worth adding a second argument.

; DefType N2N : Number -> Number
; DefType F6 : Tree (Number -> Number) -> Tree
(define (f6 [t Tree?] [n2n N2N?])
  (type-case Tree t
    [leaf (val) (leaf (n2n val))]
    [node (val left right)
      (node (n2n val) (f6 left) (f6 right))]))

The function scaled:

; DefType Scaled : Tree Number -> Tree
(let ((f lambda(x y)(* x y)))
  (define (scaled [t Tree?][n Number?])
    (type-case Tree t
      [leaf (val)(leaf (f n val))]
      [node (val left right)
        (node (f n val) (scaled left)(scaled right))])))