In klang we do need a multi-line REPL.

Describe the bug
issue when using the KIN_AMAGAMBO tandukanya method.
i am getting objects array instead of array of strings

To Reproduce
Steps to reproduce the behavior:

1. make file try.kin
2. add codes tangaza_amakuru(KIN_AMAGAMBO.tandukanya("hello world", " "))
3. run kin run ./try.kin
4. See result ([object Object])

Expected behavior
expected to get a string array.

Screenshots

Based on basic behavior, and how Kin manages return-statement, it's not easy to write recursive functions.

we need to optimize this so that it'll be able to interpret recursive functions.

Is your feature request related to a problem? Please describe.
It's not that easy to contribute core things to Kin's repo because of a vague contribution guide which doesn't show what needs to be done in a comprehensive way.

Describe the solution you'd like
A clear and concise contribution guide for other developers

For now, every in-built function is in ./src/runtime/globals.ts file.

This is not good because it's not easy to find what you want to work on or view.

Solution:

We'll add in-built folder in the runtime, each method and it's associated functions will be added to their own file, all in built methods will be imported in ./src/runtime/globals.ts where their will be added to the global environment env for use.

Is your feature request related to a problem? Please describe.
Most of people who're being introduced to programming doesn't have tools like Node.js installed. Since Kin requires it to be installed, it adds extra layer of complexity.

Describe the solution you'd like
Provide Kin's executables as independent not depending to Node.js, also add installers for linux && windows OS with clear guide to do it.

This might sound like a crazy idea but yes, we have to migrate our code base from C to C++.
Here is the reason why:

As the codebase scales our codes are getting more messy, and the solution here to introduce Object Oriented Programming Language which is also a low-level and statically typed to help us organize our codes but also help us to consume the beauty of OOP.

This might be a little bit challenging but it will benefit us in future like:

• Easy maintainance
• C++ introducing more utility function ...

It was good that we reached here by using only C.

for now we treat all errors as Error only we need to add other classes to specify each error's name and code for proper error handling.

I observed this mistake I made while implementing the parser, relational, equality and additive operators has the same operator precedence in our parser which causes problems while writing conditions.

We don't tokenize negative numbers

We repeat our selves too much while we're verifying if the number of parameters and number of arguments for native functions are the same as expected. We need to built a simple validation utility to help us avoid that. it has to be scalable so that in case we need to add further verifications it can be done easily 👍

Desc

Since our programming language will be interpreted we will need to tell user how he can use it. like list of commands and arguments so that he/she can get started.

Case

We will print usage when a user issues kin,kin help or kin -h commands in his/her terminal.
also when he/she issues unknown command we will print Command *issued-command* not found run *kin help* for usage

We don't check if number of arguments to functions are equal to number of parameters of that function.

this leads to errors like Error reading file: Cannot read properties of undefined (reading 'type').

How to fix this

• For native functions:

in globals.ts inside runtime folder, always check if args.length == number of arguments the native function has to receive

• For user defined functions

must be fixed in expressions.ts check if arguments, are equal to fn.parameters.length

Adding or removing first element from an array.

file: /src/runtime/globals.ts

These must be in-built functions, avaiable anywhere in the program

continue : this keyword will skip current iteration and go to the next one in a loop.

This issue was discovered in #117 by kin-lang/algorithms#1.

In #117 (v0.3.0)

porogaramu_ntoya garura_a(a) {
  tanga a
}

porogaramu_ntoya garura_b(b) {
  tanga b
}

porogaramu_ntoya teranya(a, b) {
  reka ab = garura_a(a)
  reka ba = garura_b(b)
  tanga ab + ba
}

tangaza_amakuru(teranya(1, 2))

Those codes returns 1 instead of 3

file : src/runtime/eval/statements.ts, on eval_loop method.

break : this keyword will stop kin's loop.
continue : this keyword will skip current iteration and go to the next one.

Desc

Since our programming language will be interpreted we will need to tell user how he can use it. like list of commands and arguments so that he/she can get started.

Case

We will print usage when a user issues kin,kin help or kin -h commands in his/her terminal.
also when he/she issues unknown command we will print Command *issued-command* not found run *kin help* for usage

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

This repository currently has no open or pending branches.

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

Kin can't parse this correctly
((var > var2) && !(var3 != var4) || (var5 == var6))

This is all about eating parentheses correctly!

Is your feature request related to a problem? Please describe.

No, add Kinyarwanda documentation to existing documentation.

Describe the solution you'd like

Since kin target the Rwanda, it would be better if the documentation, including readme are in kinyarwanda. I believe this can make it easier for Rwandan to understand this programming language.

Describe alternatives you've considered

Documentation support multiple languages like Kiswahili or French

Additional context
N/A

I encountered an error "Unhandled: undefined" while implementing the quick sort algorithm in Kin Lang. Here is the code snippet that produces the error:

reka urutonde_rwi_imibare = [34, 56, 23, 45, 34, 57]

porogaramu_ntoya igabanye(urutonde_rwi_imibare, hasi, hejuru) {
  reka pivot = urutonde_rwi_imibare[hejuru]
  reka i = hasi - 1

  reka j = hasi
  subiramo_niba(j < hejuru) {
    niba(urutonde_rwi_imibare[j] <= pivot) {
      i = i + 1
      reka ububiko_bwagateganyo = urutonde_rwi_imibare[i]
      urutonde_rwi_imibare[i] = urutonde_rwi_imibare[j]
      urutonde_rwi_imibare[j] = ububiko_bwagateganyo
    }
    j = j + 1
  }
  reka ububiko_bwagateganyo = urutonde_rwi_imibare[i + 1]
  urutonde_rwi_imibare[i + 1] = urutonde_rwi_imibare[hejuru]
  urutonde_rwi_imibare[hejuru] = ububiko_bwagateganyo
  garura i + 1
}

porogaramu_ntoya quick_sort(urutonde_rwi_imibare, hasi, hejuru) {
  niba(hasi < hejuru) {
    reka pivot_index = igabanye(urutonde_rwi_imibare, hasi, hejuru)
    quick_sort(urutonde_rwi_imibare, hasi, pivot_index - 1)
    quick_sort(urutonde_rwi_imibare, pivot_index + 1, hejuru)
  }
}

reka hasi = 0
reka hejuru = KIN_URUTONDE.ingano(urutonde_rwi_imibare) - 1
quick_sort(urutonde_rwi_imibare, hasi, hejuru)

reka i = 0
subiramo_niba(i < KIN_URUTONDE.ingano(urutonde_rwi_imibare)) {
  tangaza_amakuru(urutonde_rwi_imibare[i])
  i = i + 1
}

Error Message:
The error occurs on line 2: "Kin Error: Unhandled: undefined".

Context:
I am trying to implement merge sort in Kin Lang. The error seems to be related to the array slicing or loop conditions. Any guidance or fixes would be appreciated.

Describe the bug
issue when using the KIN_AMAGAMBO ingano method getting error (Error reading file: Cannot read properties of undefined (reading 'type'))

To Reproduce
Steps to reproduce the behavior:

1. make file try.kin
2. add codes tangaza_amakuru(KIN_AMAGAMBO.ingano("hello"))
3. run kin run ./try.kin
4. See error

Expected behavior
could get 5 as result

Screenshots