#include "base.cpp"
#include "base_unicode.cpp"
#include "new_lex.cpp"
#include "new_ast.cpp"
#include "new_parse.cpp"
#include "new_resolve.cpp"
#include "ccodegen.cpp"

// 2022.05.28 - On lambda expressions
// I think it's not wise to add the multiline lambda expressions
// As is the case with python it would require new alternative syntax.
// The idea was to imply that the whitespace significant syntax is just
// inserting '{' '}' ';' automatically and if you decide to write a brace
// it stops being whitespace significant and you can type everything with semicolons and braces
// Problem is first of all it's kind of weird to have a completly different syntax
// in a language to solve something that is a minor inconvenience,
// second of all it turned out to be kind of bad, maybe if it would be more
// complicated then it would be ok but it implies that you have to semicolon end
// a lot of thing unintuitively.
//
// Probably single line lambdas should be ok. Currently braces turn off indentation
// awareness. There might be something you can do by trying to turn that on
// problem is that complicates parsing a lot cause you have to account for multiple
// indent styles, which means error messages become bad.

// 2022.05.30 - On constructors and compound expressions
// I unified the compound expression syntax (Type){} with function call syntax Type().
// It's differentiating on whether you used type. I think there is a benefit to the language
// not having an idea of overloading the type constructor. You will always know what will happen.
// Unlike C++ for example. It seems like a minefield that can fuck your mind up. So many corner cases
// and variants. having the idea of compounds doing one thing is reassuring I think.
// You can always do a constructor by writing a function with lower case type if you want that.
// For now I don't thing it should be overloadable.
//

/// @todo
/// [x] - Typespecs should probably be expressions so stuff like would be possible :: *[32]int
/// [x] - Initial order independence algorithm
/// [ ] - Cleanup the mess with constant bindings
/// [ ] - Structs
/// [ ] - Enums
/// [ ] - For loop
/// [ ] - Switch
/// [ ] - Think about compound expressions, unify with calls - maybe Thing(a=1) instead of Thing{a=1}
/// [ ] - Lexer: Need to insert scope endings when hitting End of file
/// [ ] - Add single line lambda expressions/


int main(){
  test_os_memory();
  thread_ctx_init();
  test_unicode();
  test_types();

  map_test();
  test_array();
  test_string_builder();
  test_intern_table();
  lex_test();

  String result = {};
  // result = compile_file("order1.kl"_s);
  result = compile_file("lambdas.kl"_s);
  // result = compile_file("order2.kl"_s);
  // result = compile_file("globals.kl"_s);
  printf("%s", result.str);

  __debugbreak();
}