Recursion and function evaluation

[CICS-Oleg]

Suppose we have a function like this

(: rec-func (-> Expression Atom))
(= (rec-func $expr)
    (trace! $expr
    (if-decons-expr $expr $head $tail
        (let $res ($head) (let () (println! $res) (rec-func $tail)))
        (println! "processing finished"))))

We want to pass some other functions as arguments

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

without preliminary execution.

This type of call can't be resolved:

!(rec-func (func1 func2 func3))

The output is

[(trace! (func1 func2 func3) (if-decons-expr (func1 func2 func3) $head#21 $tail#22 (let $res#23 ($head#21) (let () (println! $res#23) (rec-func $tail#22))) (println! "processing finished")))]

However with the previous versions of Metta the output was

(func1 func2 func3)
1
(func2 func3)
2
3
3
()
processing finished

That is still not what we want, but it resolved by the interpreter.

The problem is how to achieve behavior like that:

(func1 func2 func3)
1
(func2 func3)
2
(func3)
3
()
processing finished

with the current state of Metta?

[DaddyWesker]

I need to add that if on current state of Metta (main branch of hyperon-experimental with today's clean install) we will remove type definition here is what will be. Code:

(= (rec-func $expr)
    (trace! $expr
    (if-decons-expr $expr $head $tail
        (let $res ($head) (let () (println! $res) (rec-func $tail)))
        (println! "processing finished"))))

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

!(rec-func (func1 func2 func3))

Output:

(func1 func2 func3)
1
(func2 func3)
2
3
[(Error 3 BadType)]

As I understand this behavior, on the last step when we're getting error rec-func getting called like that (rec-func 3). Why 3? Because if-decons-expr on (func2 func3) gives func2 and (func3) as $head and $tail. But, since (func3) is actually call to function, it is being evaluated when (rec-func (func3)) is being called which leads to call (rec-func 3) and if-decons-expr getting 3 as input just produces BadType error (since if-decons-expr wants Expression as input). So my suggestion was to use type, as it stated by Oleg at the start of topic. But, as it also was stated, using this type (: rec-func (-> Expression Atom)) leads to function not being evaluated at all which is kinda confusing to me. And thus I've suggested to create an issue.

[DaddyWesker]

I got some ugly solution for this particular example:

(= (rec-func $expr)
    (trace! $expr
    (if-decons-expr $expr $head $tail
        (let $res (unquote $head) (chain (eval ($res)) $evalres (let $recres (rec-func $tail) (cons-atom $evalres $recres))))
        ())))

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

!(rec-func ((quote func1) (quote func2) (quote func3)))

(by the way, eval is needed here. Without it output will be [((func1) (func2) (func3))] ). It gives this output:

((quote func1) (quote func2) (quote func3))
((quote func2) (quote func3))
((quote func3))
()
[(1 2 3)]

Function also could be rewritten like this (if you like let* more than several consequent lets and chains):

(= (rec-func $expr)
    (trace! $expr
    (if-decons-expr $expr $head $tail
        (let* (
            ($res (unquote $head))
            ($evalres ($res))
            ($recres (rec-func $tail)))
            (cons-atom $evalres $recres))
        ())))

Though it works, I personally don't like to quote function names when calling rec-func. As I understand, this should be somehow fixed by using types, but in this case it don't...

[DaddyWesker]

Well, some more interesting behavior.

(: rec-func (-> Expression Expression))
(= (rec-func $expr)
    (trace! $expr
    (if-decons-expr $expr $head $tail
        (let $res ($head) (let $recres (rec-func $tail) (cons-atom $res $recres)))
        ())))

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

!(rec-func (func1 func2 func3))

This gives:

(func1 func2 func3)
(func2 func3)
3
()
[(1 2 3)]

So, it seems that type for this case not preventing expression from being reduced on some step for last func in expression.

[Necr0x0Der]

@CICS-Oleg , I'm not sure why you are using Atom as a return type?

[Necr0x0Der]

I'm also not sure why do you need

(let $res ($head) (let () (println! $res) (rec-func $tail)))

instead of just

(let () (println! ($head)) (rec-func $tail))

[Necr0x0Der]

OK, from this

(: rec-func (-> Expression $t))
(= (rec-func $expr)
   (let () (println! $expr)
    (if-decons-expr $expr $head $tail
        (let () (println! ($head)) (rec-func $tail))
        (println! "processing finished"))))

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

!(rec-func (func1 func2 func3))

I got that the funny thing is that (func3) got prematurely reduced and we want to avoid it.

[Necr0x0Der]

The issues are

• Atom return type prevents further evaluation
• (trace $expr....) or (println! () $expr ...) evaluates $expr.

So, if we want to introduce minimum modifications to your code, it will be:

(: rec-func (-> Expression $t))
(= (rec-func $expr)
    (trace! (noeval $expr)
    (if-decons-expr $expr $head $tail
        (let $res ($head) (let () (println! $res) (rec-func $tail)))
        (println! "processing finished"))))

(= (func1) 1)
(= (func2) 2)
(= (func3) 3)

!(rec-func (func1 func2 func3))

[CICS-Oleg]

I'm not sure why you are using Atom as a return type?

It's for demo purposes only. We need expression|atom|empty| as the return type.

[CICS-Oleg]

I'm also not sure why do you need

(let $res ($head) (let () (println! $res) (rec-func $tail)))

instead of just

(let () (println! ($head)) (rec-func $tail))

To make tuple of all func's outputs.