brolang/TODO.md

"quick"/"easy" fixes

• for global initialization cycles, report also starting and ending lines

• intern strings across all phases of the compiler and reference strings by their hash/id

  • makes string comparison and equality checks faster and takes up less memory

milestones

1. get c interop working:

• link with c / compile c code into binary alongside brolang code
• create bindings from c headers
• figure out how to represent variadic arguments
  • proposal (from an older document):

    # functions with variadic arguments
    printf :: c func(fmt []u8, args ...) int  # `...` is essentially an anonomous tuple type used in function arguments. `...` collects remaining arguments in a type inferred tuple (infer from anchor)
    

    • notes on structs and tuples from same older document:

      # structs carry only data, no methods, no behavior
      Stuff :: struct {
          first u32
          second float
          third [5]i32
      }
      
      # tuples are just structs without field names (accessed via index: ``some_tuple.0``, ``some_tuple.1``, etc.)
      # anonomous tuple type inferred from literal and type anchors?
      some_tuple :: { 4, "hello" }
      

• find out how this should co-exist with the import system
  • maybe c header files should just be treated as individual packages
    • that is also typically how they're used in c projects as they define an interface to a module (or package)
    • that means that bindings should be automatically generated by the compiler when the user imports a c header file:
      • import "relative/path/to/some_header.h" - wraps the c header file in a brolang package called some_header
      • other_header :: import "relative/path/to/some_header.h" - wraps the c header file in a brolang package called some_header into other_header namespace
      • implementation of the functions declared by the generated bindings is provided by the c implementation and requires the c implementation to be linked with the brolang binary
    • this requires the ability to declare a "bare" function (as an interface) that is linked to the c implementation

      # declare the bare extern function for c interop (notice only the signature is provided, not the implementation)
      # this should only be allowed for extern functions, i.e. `c func`
      extern_c_sum :: c func(a, b int) int