DeadWisdom/DazzleLang.md

## DazzleLang.md

      
    Raw
  

              DazzleLang.md
            
          
    // Schemas are defined in a ui, not in text, they are too rich
// States are defined in a ui, not in text, they are too rich

calculateAverages(cells: Cells) {
    // This function has no context (this/self)
    // It is pure, no side-effects
    // It cannot run tasks
    // It can't modify tables, or any data really
    // It can be given table cells as arguments to read, but again can't modify them
    // It must be performant
    // The compiler checks that it is branch complete
    // In the UI when you make a new function, the first thing it does is ask you for examples
    // Functions can be run in cells with =, like in a spreadsheet "=calculateAverages(#name)"
    total = sum(cells)
    return total / cells.length
}

getAnomalousCells(cells: Cells) -> [Cell] {
    // Return type optional like in TypeScript
    // Functions can be 'chained' like in unix, with the pipe `|`
    return calculateAverages(cells)
           | filter (cell, avg) => avg > 5.0
           | forEach (cell, avg) => cell
}

task notifyUser(user) {
    // Tasks have a context 'self'
    // Tasks do not return a value
    // Tasks can send messages to other services/actors in the system
    // Tasks can read/write tables
    await notifications.send('anomalous', user)
}

task notifyAnomalousUsers() {
    // For every user cell, schedule the notifyUser task in 10 seconds, then sleep .1 seconds
    // to do it gradually.
    // 'self' here is table this task is defined on. self.users == the users colum
    getAnomalousCells(self.users)
    | forEach (user) => schedule notifyUser(user) 10s   // duration literal, 10 seconds
    | sleep(.1s)
}

on mouseDown(event) {
    // This trigger can only be running once, automatically debounces
    super.send(event)
    await notifyAnomalousUsers() 
    goto sent // Move to sent state
}

on every keyDown(event) {
    // This trigger will run in parallel every time the event happens
    run console.log("keyDown: {}", event.keyName)
}

on init => loaded {
    // When we go from init state to loaded state
    run notifyAnomalousUsers()

    return {
      loaded = true
    }
}

on "reload" init => loaded {
    // Named trigger, has a guard which will only run the trigger if the guard is satisfied
    guard hasBeenLoaded

    return {
        reloaded = true
    }
}

guard hasBeenLoaded {
    return context.loaded
}

guard hasTitle {
    return context.__title
}
functions


functional style
all pure + (global/higher/self context?)
have local variables, all immutable by default
lazy evaluated
no side-effects
cannot schedule tasks
cannot read/write to tables
must be performant (!!!)
graphed / reactive
measured for completeness (ooh)

tasks (aka coroutines / routines / procedures)


imperative style
can read/write to tables
allows side-effects
always async
can be scheduled
can be awaited
can call functions
can call other tasks
can be build like: task = notifications.send.create(name='anomalous', user=user)
can be used like await task, run task, defer task, errdefer task, schedule task <when>

defer, like in zig schedules it for the end of scope to be run then
errdefer similarly runs only when an exception occurs


can be called directly run notifications.send('anomalous', user)

triggers


trigger when sent a message
imperative style
just like tasks
given exactly one argument (the message)

state triggers


trigger when enter a state from another
returns a state context update

redefine these as spreadsheet tables


sets
lists
maps
state machine ???
= table[name=bob].age + 1

tables/columns can have various run-time constraints


uniqueness
sorted
selection / state
indexes

cells


can be functions with '=' (above)
are strongly typed

state-machine


actor / service
maps states to functions

services


tracked by the routines that call them as part of the definition

data-oriented


sorta is
could we reframe tasks or functions as "systems"? Or maybe make a new type.