webscript (wip concept) (inspired by c++)

_ reserved keywords and symbols

as
define
import
@
&
:
?
()
[]
.

inheritance.web

import std.type

std.type foo (

)

std.type bar + foo (

)

main.web

import std.boolean
import std.function
import std.integer
import std.string
import std.type

std.function[ foo: std.integer, bar: std.boolean ] do_something -> std.string (
    std.if[ bar ] -> 'foo'
    std.match[ foo ] (
        0: -> 'hello'
        1: -> 'world'
        std.none: -> 'bar'
    )
)

do_something[ 0, false ]

std.type app (
    std.integer app_status: std.none
    std.string app_title: std.none

    std.function[ title: std.string ] app -> app (
        app_status: 0
        app_title: title
    )
    
    std.function[ status: std.integer ] exit -> std.none (
        app_status: status
    )
    
    std.function[ ] start -> std.none (
    
    )
)

app example[ 'example' ]

example.start[ ]
example.exit[ 1 ]

std.function.web

import std.any
import std.map
import std.namespace
import std.operator
import std.symbol
import std.type
import std.vector

std.namespace std (

    std.type function[ argument_types: std.map[ std.symbol, std.any ] ] (
    
        std.operator[ return_type ] -> ? (
            
        )
    
        std.operator[ ...arguments ] [ ? ] (
        
        )
    )
)

std.if.web

import std.boolean
import std.macro
import std.namespace

std.namespace std (
    
    std.macro if[ condition: std.boolean ] (
        
    )
)

std.map.web

import std.namespace as namespace
import std.type as type

namespace std (

    type map[ key_type?, value_type? ] (
    
    )
)

std.pool.web

import std.function
import std.if
import std.integer
import std.namespace
import std.none
import std.or
import std.type
import std.vector
import std.while

std.namespace std (

    std.type pool[ fill_type? ] (
        std.function[ ] pool_allocator -> fill_type
        std.vector[ fill_type ] pool_contents
        std.integer pool_size
        
        std.function[ size: std.integer, allocator: std.function[ ] -> fill_type ] pool -> pool (
            pool_allocator: allocator
            pool_size: size
            
            resize[ size ]
        )
        
        std.function[ ] contents -> @std.vector[ fill_type ] (
            -> pool_contents
        )
        
        std.function[ ] empty -> std.boolean (
            -> pool_contents.empty[ ]
        )
        
        std.function[ ] size -> std.integer (
            -> pool_contents.size[ ]
        )
        
        std.function[ size: std.integer ] resize -> std.none (
            std.if[ pool_size > size ] (
                std.while[ pool_contents.size[ ] > size ] (
                    pool_contents.pop_back[ ]
                )
            ) std.or (
                std.while[ pool_contents.size[ ] < size ] (
                    pool_contents.push_back[ pool_allocator[ ] ]
                )
            )
            
            pool_size = size
        )
    )
)

std.type.web

import std.macro
import std.namespace
import std.operator

std.namespace std (

    std.macro type (
        
        std.operator[ ...arguments ] [ ? ] (
        
        )
    )
)