overview.kek

# single line comment
##
Multi line comment

-> Commas are optional

Code is organized in files.
Files can be imported using use.
Usually just git clone the repos.
Otherwise just paste the code files/libs.

-> Dont make packages to easy to add, so we dont end
up in the same mess as npm.

##

    ##
        You can set rules for all scopes
        Scopes inherit the rules from the parent scope
    ##
    use RuleSet(
        no_fuck_around = true
    )

    ##
      Use called as a function
      imports a module
      -> it only loads the module once
      -> modules never contain logic.

      Except for the main module
    ##
    # if you load a type into an alias it needs to be an upper case letter
    # Files also need to start with an upper case letter
    Std :: import("std")  # load the whole std module into this const
    out :: import("std.fmt").out
    MyClass :: import("./path/to/file/with/MyClass").MyClass

    # the type of a const with a module within is a "module"
    # then function, struct, trait, or some other value
    # module constants are special, in that they can be called to get their consts
    # but only the exported ones

    # modules can span multiple files, but they need to be
    # in the same module directory.

    my_const :: 1

    my_fn :: fn(a:Int b:Int) -> Int {
        return a + b
    }

    MyEnum :: enum{ KEK::1 LOL::2 ROFL::3 }

    ##
    A trait is basically a interface, as well as a code reuse
    vehicle for object composition.
    This depends on the use.
    ##
    MyTrait :: trait{

       field: Int

       static_field :: 123

       abstract_method : Fn(Self)->String

       abstract_static_method :: Fn()->String

       method_to_share : fn(self){
          out( self.field )
       }

    }

    # structs and traits NEED TO BE UpperCase


    ##
        Structs allow to structure data.

        You can use traits to compose structs or to
        ensure functionality on structs.

        Structs can have methods and static methods, so
        a struct can also act as a name-space.
    ##
    MyStruct :: struct{

        use MyTrait
        # this adds all the runtime type info
        # methods and data to this struct.
        use RuntimeTypeInformation

        some_other_field: Int

        abstract_method : fn(self) -> String {
          return "implemented" + self.field
        }

        # scope is the static scope of the struct definition
        abstract_static_method :: fn(scope)->String {
            return "implemented" + scope.static_field
        }

    }

    GenericTrait :: trait(T){
        field: T
        method :: fn(self) -> T
    }

    GenericStruct :: trait(T: TraitThisTypeNeedsToImplement){
        field: T
        method :: fn(self) -> T
    }

    # generic struct
    MyGenericStruct :: struct(
        T1: TraitThisTypeNeedsToImplement
        T2: TraitThisTypeNeedsToImplement
    ){
        field: T1
        field2: T2
        method :: fn(self) -> T1 {
            return self.field
        }
    }


    Utils :: struct(RuleSet(namespace = true)){
        RuleSet(namespace = true) #  this struct can only contain static methods and other static field values
        add :: fn(a:Int b:Int) -> Int {
            return a + b
        }
    }

    # we can use ruleset to disable the creation of an struct via literal
    # or even make fields private
    ILoveOOP :: struct{

       use RuleSet(
         outside_literal_creation = false
       )

       a: Bool
       b: MyStruct

       new :: fn() -> self {
          return self(
             a = false,
             b = MyStruct()
          )
       }

    }

    # we can put together rulesets
    # the ruleset itself has the const-values only rule
    # so you cannot put in expressions, only literals
    strict_function_rules :: RuleSet(
        allow_variables = false
    )

    # functions can only see const values from the top level scope
    foo :: fn(){
       # nice we can set the rules for our function
       use strict_function
    }
    other_foo :: fn(){
       # nice we can set the rules for our function
       use strict_function
    }

    number_guess :: fn(number: Int) -> Union(Bool, Error, String){
       if number < 0 {
          return ->(bool = false) #-> shorthand for return type construction literal Union(Bool, Error, String)
          # return Union(Bool, Error, String)(bool = false)
       }elif number > 100 {
          return ->(error = Error("You suck"))
       }else{
          return ->(string = "Eat Ass!")
          # return -> induces the return type
       }
    }

    get_option :: fn() -> Option(MyStruct) {
      return ->(some = false)
    }

    main :: fn(){

        local_const :: MyStruct(
           field = 124
           some_other_field = 124
        )

        variable := MyStruct(
           field = 124
           some_other_field = 124
        )

        variable.field = 99999

        if my_struct := get_option?value {
            out("nice we got a value")
        }else{
            out("bad...")
        }

        myList := List(MyStruct)()

        myMap := Map(String MyStruct)(
           "Kacke" = MyStruct(
              field = 124
              some_other_field = 124
           )
        )

        myList2 := List(Int)(1 2 (3-4) 5 6 7 8 9)
        # the -> before a ( means assume the type of the construction literal from the left hand side

        localf :: fn(a: List(Int)){}
        localf(->(1 2 3 4 5 6 7))

        for i := 0 .. myList2.len {
            out(i)
        }

        for i := 0 .. myList2.len; 2{
            out(i)
        }

        if(b := number_guess()?bool){
            out("we got " + b)
        }elif(s := _?string){
            out(s)
        }elif(err := _?error){
            out(err.message)
            out(err.traceback)
        }


        b := 14

        {
          a := 124 + b
        }

        # a is not defined here

        (){
          a := 124 # b isnot defined here
          # since the () makes this a capture block
        }


        a := ->( 1 2 4 5 6 ) #  type induced

        tuple := ->(1 true "kek" 1.2) # type == Tuple(Int, Bool, String, Float)

        b :: ->(
            "KEK" = "LOL"
        )

        needs_vector(->(x=2 y=3 z=4))

        (b){
          a := 124 + b
        }

        {

         a := (b) -> { # this is a return block
            return 124 + b
         }

         {
             a := -> {  # this is a return block
                return 124 + b
             }
         }

        }

    }

    ##
        Local keyword
        -> before a field means
        that this field can not leave the scope
        -> so it is basically an private field

        -> local in a function means that the variable
        can not be set to any value from outside the
        using scope.

        -> this means, that if we share a reference we know
        that it will not appear in another portion of persistent
        state.

    ##
    local_struct :: struct{
        # field definitions
        aa : Int
        aa : Int
        aaa : Int
        private_const : local const Int
        a : local Int
        b : local Int
        my : local MyStruct

        ##
            My struct can be read but not set to a leaking field outside the scope
            Only to a local field in the calling scope
        ##
        get_my_as_local :: fn() -> local MyStruct {

            local_const_field :: local MyStruct(
                field = 124
                some_other_field = 124
            )

            local_variable_field := local MyStruct(
                field = 124
                some_other_field = 124
            )

            out(local_const_field.field)

            return my
        }

        # now MyStruct can not even be changed by the calling scope
        # and only be assigned to local const values
        get_my_as_local_const :: fn() -> local const MyStruct {
            return my
        }

        get_readonly_param :: fn(
            localParam: local MyStruct
        ){}

        get_readonly_param :: fn(readOnlyParam: const MyStruct){
        }

        get_readonly_param :: fn(readOnlyParamNoLeak: local const MyStruct){
        }


    }

    pure_function :: fn(a: local const MyStruct) -> local const MyStruct {
        return a
    }

    instances :: List(MyStruct)

    {

        instances.append(MyStruct(
            field = 124
            some_other_field = 124
        ))

        local my_struct := MyStruct(
            field = 124
            some_other_field = 124
        )

        instances.append(my_struct) # this is not allowed

        local mys2 = my_struct.getmy_as_local() # this is allowed

        instances.append(my_struct) # this is not allowed
        # error would be: Type-Error local value my_struct is not allowed to leave the scope
        # append would need to consume a local value
        # but this is not the case with append, since
        # append would assign the value to the inner state

        # local in the variable list is the promise that the variable
        # will not be set to from outside the scope
        # so if the function has concluded
        # no references to the passed in variable will exist
        mf :: fn(m: local MyStruct) {
            out(m.field)
        }

        # const means value cannot be changed
        # but could "leave the scope"


        # maybe we can create "managed" values?
        # which are refernce counted??

    }

    # offer full c interop by offering pointers and structs
    # pointer are disabled in modules by default but can be
    # enabled.
    # so we can write code that calls s code directly in kek

    # do we need a cfn keyword to define the c functions
    # cfn
    # ?

    # or can we use Ptr() or Addr() as special type for this case?
    # MemoryArray()  -> C-array
    # usw.





}