tutorial.kek

# Single Line Comment

##
Multi Line Comment
Multi Line Comment
##

##
  newlines and multiple whitespaces are ignored
  Commas are not needed and are removed by the tokenizer,
  you can however use them if you want for readability

##

   import std:out as out
   # this file is parsed
   # all exported types (marked as pub), get a prefix
   # then we go over this file and
   # place the prefix in front of the "my_function"
   # in every use
   # we keep track of already imported files
   # so we dont import the same file twice
   import "path/to/file":my_function as my_function
   # if the file cannot be found locally the compiler
   # looks in te global paths, etc..

   # scopes can be nested
   {}

   # scopes behave like in c
   # variables declared inside a scope are not accessible outside the scope
   # the default scope can see and use all variables declared
   # and available in the parent scope
   a :: 124  # const
   {
      b :: 123
      c :: a + b
   }
    # c and b are not accessible here

   # adding () makes the scope into a capture scope
   # now only the names in the capture list are accessible
   b :: 123
   (a){
      c :: a + a
      # b is not accessible here
   }

   # scopes can return values
   c :: ->Int {
      return 123
   }

   # returning scopes can be capturing as well
   d :: (c) -> Int {
      return c + 1
   }

   ##
   define a variable
   with :=

   Change a variable with "set"
   "set" is mandatory, since mutation of state should
   made explicit.

   ##

   my_var := 123

   set my_var = 124  # set statement

   ##
     Control flow

     Kek only has if statements and for loops
   ##

   if a  == 1 {
      # do something
   }
   elif a == 2 {
      # do something else
   }
   else {
      # do something else
   }

   start :: 0
   end :: 10
   stepsize :: 1

   for i := start .. end; stepsize {
       # do something
   }

   for i := 0 .. 10; 1{
      # do something
   }

   ##

   Functions

   Functions are NOT first class citizens in Kek, they are
   more like C functions, but without function pointers.

   The need to be declared as const (as ::).

   ##

   fn foob(a:Int b:Int) -> Int {
     ret a + b
   }

   out(foob(1 3)) # 4

   ##
    enums

    Enums are simple structs, where you only can declare
    const values of the same type.

    All types need to start with an upper case letter.
    Only types are allowed to start with an upper case letter.

   ##

   enum MyEnum{
     A :: 1
     B :: 2
   }

   ##
    structs

    Structs are used to structure data.


    Structs and functions can only be defined on the top level.

   ##

   struct MyStruct {
      a: Int
      b: Int
      myList: [MyStruct]
   }

   a :: MyStruct.static_const_field  # 12

   mys :: MyStruct(a=1 b=2) # calling a type -> construction literal

   ##
    Methods

    Structs can have methods, this allows for a simpler
    call syntax.

    A method is a function in a struct that has the
    "self" argument as the first argument.

    Other than that methods are normal functions.
   ##

   struct MyName {

      a: Int

      fn myMethod(self: MyStruct){
        out(self.a)
      }

   }

   mys :: MyStruct(a=1)

   mys:my_method()  # 1 # call methods with :
   p:apply(_(x=69 y=69))

   ##
   optionals

   Kek code is statically typed.

   So we need a type for values that can be nil.

   To unpack an option, we need to use the ? operator
   with the unpack syntax in the if statement.
   ##

   fn foo(a: Bool) -> Player|nil {
     if a {
       ret Player(x=1 y=2)
     }
     ret nil
   }

   option :: foo(true) #  type: Player?
   if p :: option ?? Player { # unpack syntax -> can also be "p := ?option"
     # p is now like defined in this scope and cannot leave it
     out(p.x)
   }
   else{
     out("nil")
   }

   ##
   unions

   We can return union-types.

   This is used instead of try-catch blocks, but
   can also be used for other things.

   ##

   fn handle(a: Bool) -> Player|String {
     if a {
       ret Player(x=1 y=2)
     }
     ret "error"
   }

   result :: handle(true) # type: Player | String
   if player :: result ?? Player {
     out(player.x)
     # do more with player
   }
   elif error :: result ?? String {
     out(error)
   }

   ##
   Array and Map(Dict)

   Kek has a built in array and map type.

   If a value that is not a type is followed by a .(
   this is interpreted as accessing the value at the index.

   It qualifies as a indentifier can can stand on
   the left side of an assignment.

   Since we only have list and map as generic types
   we can only expect ( and ) if it is preceded by a type.
   ##

   {
     arr := [Int](1 2 3 4 5)
     map :: [String Int]("a"=1 "b"=2 "c"=3)

     out(arr:(0))
     out(arr:(1))
     out(map:("a"))
     out(map:("b"))

     set arr 0 = 123
   }

   ##
   const & local

   Function arguments and return types can be denoted as const and local.

   If an argument is denoted as const, it cannot be changed within
   the function - even if its is mutable outside the function.

   IF an argument is denoted as local, this argument cannot be set to any
   value that does leave the function scope, expect into function that
   have the same local argument.
   So local ensures, that there is no new state containing the local reference
   after the function has concluded.

   If a return type is const, the return value can only be set to
   a const field or passed into a const argument. Const is part of the type.

   If a return type is local, the return value can only be set to
   a local field or passed into a local argument. Local is part of the type.

   ##

   # todo: add example

   ##
    Scope Rules & rule-scopes

    Each scope can have compile time rules set.
    Each scope inherits the rules from the parent scope.

    Rules can also be added together and applied to multiple scopes.
   ##

   {
     ruleset only_const = true

     a :: 123

     # not allowed
     # b := 123

     {
       # not allowed
       # c := 123
     }

     {
       rule only_const = false

       b := 123
     }
   }

   MyFunctionConstraints :: rules{
      only_const :: true
      only_local_args:: true
   }

   my_c_f :: fn(){
     ruleset MyFunctionConstraints
     # now all rules are applied here ...
   }