function support in ftd

[amitu]

Main discussion: #434

We want people to be able define functions in FTD.

YouTube discussion about this topic:

Event Handler Functions

Side effect functions are function that mutate some value. They can not directly mutate a global, they have to be explicitly passed the mutable reference to a variable so they can mutate that variable. Side effect functions have type event-handler. event-handler functions can only be used as event handlers.

-- integer y: 10

-- event-handler increment:
caption integer $what:
integer by: 1
optional integer clamp:
integer x: foo: by + 1
> operation: addition


--- integer new = $what + $by

--- if: $clamp && $new > $clamp 
> $new: some-function: $y
>> x: if: $y
>>> 10
>> else:
>>> 12
else:
> $x:

--- integer foo: some-other-event-handler: $new
> $what: $what
> something: $y
> something-else: some-other-function: $y
>> second-arg: of-some-other-function

--- $what: $new

Pure/Expression Functions

Then we have normal functions, they do not mutate anything, but return a value:

-- decimal force:
decimal mass:
decimal acceleration

if $newton-was-right {
    return $mass * $acceleration
}

0

Such function are pure and can only be used as expression, eg:

-- decimal m: 1.0
-- decimal a: 1.0

-- ftd.decimal: force: mass=$m, acceleration=$a
size: ciel: (force: mass=$m, acceleration=$a)

-- decimal-slider:
$value: $m    ;; initial value of slider
low: 0.0
high: 1000.0

Trying end syntax

-- decimal m: 1.0
-- decimal a: 1.0

-- ftd.decimal: 
size: ciel: (force: mass=$m, acceleration=$a)

-- ftd.decimal.value: 

-- force: 
acceleration: $a

-- force.mass:

This is a mass

-- end: ftd.decimal.value

Attempt 2

-- ftd.decimal: (
    force: mass=$m, acceleration=$a
)
size: ciel: (force: mass=$m, acceleration=$a)

Using Functions In FTD

-- integer y: 10
-- decimal x: (log: $y) * 2      ;; formula / expression

-- slider:
$value: $y   ;; pass mutable reference of $y to slider, inside slider this ref is called $value

-- ftd.integer: $x
size: (ceil: $x) + 1
id: i

Why Are We Even Considering This Weird Syntax

-- ftd.text: hello
size: 10

-- foo: 
title: ftd.text: hello
> size: 10
size: factorial:
> n: 10

-- ftd.row foo:
ftd.ui title:
integer size:

Dependency Graph And Page Updates

Is a DAG (directed acyclic graph).

y -> [(i.text, "fn1"), (i.size, "fn2")]

function fn1(y) {
   log(y) * 2
}

function fn2(y) {
   ceil(log(y) * 2) + 1
}

[Arpita-Jaiswal]

We will be more like C. Only functions. Struct is like a record for us and is defined using record syntax. Arguments would be python like, keyword argument and default values supported. We can use ftd syntax for defining arguments.

-- string foo:
integer x: 10

-- string foo.y:

Whatever

-- foo.body:

integer i = 10;
string a = "";

while (i < x) {
    print("this will go to console");
    a += y;    
}

return a;

In rvalue we either expect $x or {x + 1}. If you just want the value, you can use $x, but if you want to use any expression at all you have to surround the expression in {}.

Let's not have conditional header syntax because we now have expression support.

-- foo:
color if {x > 1}: $fpm.color.background

-- foo:
color: hello {
    if x > 1 {
        fpm.color.background
    }
}

If expression does not give a value, it returns null.

-- ftd.text: hello {amitu},

Will not compile because $amitu is a record instance.

-- ftd.text: hello {person_to_string(amitu)},

Or even

-- record person:
caption name: 

-- string person.to_string:

self.name

-- ftd.text: hello {amitu.to_string()},

-- record person:
caption name: 

-- string to_string:
person self:

self.name

-- ftd.text: hello {to_string(self: amitu)},

ftd.ui functions

We can also define ftd.ui functions:

-- ftd.row show-person:
string name:

-- ftd.ui foo:
person p:

return show-person(
    name: p.name
)

Methods

-- record person:
caption name: 

-- string person.to_string:

self.name

-- ftd.text: hello {amitu.to_string()},

-- ftd.row person.display:
integer foo: 0

-- ftd.text: {times(self.name, foo)}

-- end: person.display

-- person amitu: Amit Upadhyay

-- amitu.display:
foo: 20