jokebookservice1 wrote:

conwayslife wrote:

jokebookservice1 wrote:

conwayslife wrote:

jokebookservice1 wrote:

Buster_McMuffin wrote:

define (x)^(y)
repeat (y)
    set [result] to ((x) * (x))
end

The correct workaround for integers is:

define (x)^(y)
repeat (y)
    set [result v] to ((result) * (x))
end

This style of workaround works in this case. However, it does not work if you want a recursive function to call itself twice. I would like something like:

define Recursive Function (input1) (input2)
if <basecase::grey> then
    return (something1::grey)::custom
else
    return (doSomethingWith (Recursive Function (something2::grey) (something3::grey)::custom) (Recursive Function (something4::grey) (something5::grey)::custom)::grey)::custom
end

There is no easy workaround for this. So in this case, custom reporters would be very helpful.

For example factorial:

define Factorial (input1)
if <(input1) = (0)> then
    return (1)::custom
else
    return ((input1) * (Factorial ((input1) - (1))::custom)) ::custom
end

Factorial can be done with the workaround, although it is less nice than the custom reporter way:

define Factorial (input1)
if <(input1) = (0)> then
    set [result v] to [1]
else
    Factorial ((input1) - (1))
    set [result v] to ((input1) * (result))
end

The problem occurs with a recursive function that calls itself twice, and does something with the outputs. The second call to the function would override whatever variable you store the first result in.
For example, in this Fibonacci calculator:

define Fib (n)
if <(n) = (0)>
    return [0]::custom
else
if <(n) = (1)>
    return [1]::custom
else
    return ((Fib ((n) - (1))::custom) + (Fib ((n) - (2))::custom))::custom

There is no easy workaround; you cannot store the first value in a variable without it getting overwritten by the second recursive call. You can use lists, but it becomes a nightmare.
(And yes, I know this is a horribly inefficient way of calculating Fibonacci numbers, but it was the simplest example I could think of. Sometimes multiple recursive calls are necessary though. In the Hashlife algorithm (which I coded in Scratch), there is a recursive function that calls itself thirteen times.)

13 times! Wow!
If anybody needs to use lists for the workaround, I have a library for that. But I would like custom reporters ASAP

repeat until []
end

set [ v] to [ v]

block (2)

define block (input)
say (input) for (1) secs
set [input v] to [3] :: custom-arg
say (input) for (1) secs

define Fib (value1) :: reporter
{
if <(value1) = [0]> then
 report [0] :: custom cap
else
 if <(value1) = [1]> then
  report [1] :: custom cap
 else
  report ((Fib ((value1) - (1))) + (Fib ((value1) - (2)))) :: custom cap
 end
end } (report [] :: custom cap) :: custom cap

Cameron_Johnson wrote:

#2

Ravenpaw-Warrior wrote:

Cameron_Johnson wrote:

#2

Sorry, but why did you bump a old topic?

The_Amaru wrote:

If it were like eight months, It would count as a necropost.

Jonathan50 wrote:

The_Amaru wrote:

If it were like eight months, It would count as a necropost.

I think it would if it was anything more than two months.