# Getting Started with Soplang

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Welcome to Soplang! This guide will help you install Soplang, set up your development environment, and write your first Soplang program.

1. Installation [#1-installation]

Before you can start programming with Soplang, you need to install it on your system. Choose the installation method that works best for you:

Option 1: Direct Download [#option-1-direct-download]

**soplang-installer**

```bash
soplang --install
```

*Welcome to the Soplang installer. Please select your operating system...*

Option 2: Package Managers [#option-2-package-managers]

**package-manager-install**

```bash
soplang --package-manager
```

*Choose your preferred package manager to install Soplang...*

For more detailed installation instructions, check out our [comprehensive installation guide](/docs/installation).

2. Your First Soplang Program [#2-your-first-soplang-program]

Now that you have Soplang installed, let's write a simple "Hello, World!" program:

<SoplangCodeWindow
  title="hello.sop"
  code={`// This is a comment
print("Hello, World!")

// Variables
name = "Soplang"
version = 1.2
print(f"Welcome to {name} version {version}!")

// Simple function
def greet(person):
return f"Hello, {person}!"

message = greet("Developer")
print(message)`}
/>

Save this code in a file named `hello.sop`.

Running Your Program [#running-your-program]

To run your Soplang program, open a terminal or command prompt and navigate to the directory where you saved the file. Then run:

```bash
soplang hello.sop
```

You should see the following output:

```bash
Hello, World!
Welcome to Soplang version 1.2!
Hello, Developer!
```

Congratulations! You've just written and executed your first Soplang program.

3. Basic Concepts [#3-basic-concepts]

Variables and Data Types [#variables-and-data-types]

Soplang is dynamically typed, meaning you don't need to declare variable types. The language supports common data types like strings, numbers, booleans, lists, and dictionaries.

<SoplangCodeWindow
  title="data_types.sop"
  code={`// String
name = "Soplang"

// Integer
version = 1

// Float
pi = 3.14159

// Boolean
is_awesome = True

// List
languages = ["Somali", "JavaScript", "Soplang"]

// Dictionary
features = {
"syntax": "clean",
"learning_curve": "gentle",
"performance": "excellent"
}`}
/>

Control Flow [#control-flow]

Soplang uses indentation to define code blocks in control structures:

<SoplangCodeWindow
  code={`// If-else statement
age = 25
if age < 18:
  print("You are a minor")
elif age >= 18 and age < 65:
  print("You are an adult")
else:
  print("You are a senior")

// For loop
for language in ["Somali", "JavaScript", "Soplang"]:
print(f"I like {language}")

// While loop
count = 5
while count > 0:
print(count)
count -= 1
print("Blast off!")`}
  title="control_flow.sop"
/>

Functions [#functions]

Functions in Soplang are defined using the `def` keyword:

<SoplangCodeWindow
  code={`//Simple function
def greet(name):
  return f"Hello, {name}!"

// Function with default parameter
def power(base, exponent=2):
return base \*\* exponent

// Function with type hints (optional)
def add(a: int, b: int) -> int:
return a + b`}
  title="functions.sop"
/>


# Installing Soplang

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

This guide shows two easy ways to get started with **Soplang**: downloading a prebuilt release or using the official Docker image.

General Download (All Platforms) [#general-download-all-platforms]

1. **Download:** Grab the latest release for your platform from the [downloads page](/downloads).
2. **Extract / Install:** Unzip or install the package as provided by the release. If it’s a single binary, place it somewhere in your PATH (e.g., `~/bin` on UNIX-like systems).
3. **(Optional) Add to PATH:** Ensure the `soplang` binary is available on your PATH. For example (shell/zsh):
   ```shell
   echo 'export PATH="$HOME/bin:$PATH"' >> ~/.shellrc && source ~/.shellrc
   ```
4. **Verify:** Open your terminal and run:
   ```shell
   soplang --version
   ```

Run Your First Program [#run-your-first-program]

**hello.sop**

<SoplangCodeWindow title="hello.sop" code={`qor("Hello, World!")`} />

Execute the file:

```bash
soplang hello.sop
```

Use Docker (No Local Install) [#use-docker-no-local-install]

If you already have Docker, you can run Soplang without installing anything else.

1) Pull the Image [#1-pull-the-image]

```shell
docker pull soplang/soplang:latest
```

2) Run an Interactive Session [#2-run-an-interactive-session]

```shell
docker run -it --rm soplang/soplang
```

3) Run a Local File [#3-run-a-local-file]

Mount your project directory and execute a file:

```shell
# from your project directory
docker run -it --rm -v "$PWD":/app -w /app soplang/soplang soplang hello.sop
```

Checksums & Offline Install [#checksums--offline-install]

* **Verify downloads:** Compare the file’s checksum with the one on the [downloads page](/downloads).
* **Offline:** Keep the extracted folder/binary and run directly—no internet required after download.

Troubleshooting [#troubleshooting]

“command not found” [#command-not-found]

Make sure `soplang` is on your PATH, or run it via Docker as shown above.

Permission denied (UNIX-like) [#permission-denied-unix-like]

If you downloaded a binary, grant execute permissions:

```shell
chmod +x /path/to/soplang
```

Still stuck? [#still-stuck]

Check the [downloads](/downloads) page notes or ask in [community support](/community).


# Soplang Syntax

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Soplang Syntax [#soplang-syntax]

Soplang syntax waxaa loo qaabeeyey in ay noqoto mid cad, kooban, oo si sahlan loogu fahmo af-Soomaali. Waxay isticmaashaa ereyo Soomaali ah si ay u metesho fikradaha barnaamijyada caanka ah, taas oo ka dhigaysa koodhku mid dabiici ah oo la akhrin karo.

Hello World [#hello-world]

Tani waa barnaamijka ugu fudud ee Soplang. Waxay adeegsanaysaa shaqada-dhexdeeda `qor()` si ay u muujiso wax soo saar.

**hello-world.sop**

<SoplangCodeWindow title="hello-world.sop" code={`qor("Hello, Adduun!")`} />

Structure [#structure]

Barnaamijyada Soplang waxay ka kooban yihiin qaybahaan:

* **Declarations** – adigoo adeegsanaya `door`, `abn`, `jajab`, ama `madoor`
* **Functions** – adigoo adeegsanaya `hawl`, `celi`
* **Control flow** – adigoo adeegsanaya `haddii`, `ugudambeyn`, `celi`, iwm.
* **Built-ins** – sida `qor()`, `gelin()`, `nooc()`

Blocks waxaa lagu qeexaa laalaabyo (`{}`) koodhkuna wuxuu ku socdaa khad-khad.

Example Program [#example-program]

Tusaalahan waxa uu akhriyaa gelinta isticmaalaha kadibna wuu salaamaa. Waxa uu ka kooban yahay: *qeexid hawl (function)*, *doorsoome*, iyo *built-ins*.

**example.sop**

<SoplangCodeWindow
  title="example.sop"
  code={`hawl salaan(magac) {
  qor("Asalaamu calaykum, " + magac)
}

door magaca = gelin("Magacaaga qor: ")
salaan(magaca)`}
/>

File Extension [#file-extension]

Faylasha il-koodhka Soplang waxay adeegsadaan kordhinta `.sop`. Waxaad ku ordi kartaa CLI ama REPL-ka Soplang:

**run.sh**

```shell
soplang file.sop
```

Syntax-kan waxa uu ku barayaa qulqulka iyo dareenka Soplang: fudayd, muujin, iyo Somali-first.


# Input and Output

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Input and Output in Soplang [#input-and-output-in-soplang]

Soplang waxay isticmaashaa shaqooyin-dhexdeed fudud si loo soo bandhigo wax soo saar iyo in lagu akhriyo gelinta isticmaalaha.

qor() – Print to Console [#qor--print-to-console]

Adeegso `qor()` si aad u muujiso qiimayaal ama xarfo (strings) shaashadda.

**print\_console.sop**

<SoplangCodeWindow
  title="print_console.sop"
  code={`qor("Hello, Adduun!")
door magaca = "Aamina"
qor("Magaca: " + magaca)`}
/>

gelin() – Read from User Input [#gelin--read-from-user-input]

Adeegso `gelin()` si aad u weydiiso isticmaalaha gelin. Qiimaha wuxuu had iyo jeer kusoo noqdaa *string*.

**read\_input.sop**

<SoplangCodeWindow
  title="read_input.sop"
  code={`door magaca = gelin("Magacaaga qor: ")
qor("Waad ku mahadsan tahay, " + magaca)`}
/>

Haddii aad u baahan tahay is-beddel nooc (type conversion), waxaad adeegsan kartaa `abn()` si aad ugu rogto tiro.

**type\_conversion.sop**

<SoplangCodeWindow title="type_conversion.sop" code={`door da = abn(gelin("Da'daada qor: "))`} />


# Variables

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Soplang Variables [#soplang-variables]

Soplang variables waxaa lagu qeexaa erayo Somali-first ah oo ka tarjumaya doorka ama nooca. Tani waxay ka dhigtaa koodhka mid muujin leh oo u fudud barayaasha Af-Soomaaliga.

Dynamic Variables – door [#dynamic-variables--door]

`door` waa soo gaabinta *doorsoome* oo loo adeegsado doorsoomayaal *dynamically typed*.

**dynamic\_variables.sop**

<SoplangCodeWindow
  title="dynamic_variables.sop"
  code={`door magaca = "Aamina"
door da = 19
door xaqiiqo = run`}
/>

Static Variables [#static-variables]

Doorsoomayaasha *static* waa kuwa si cad loo noocqeeyo (explicit types) si loo helo hufnaan iyo badbaado nooc (type safety).

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Type
      </TableHead>

      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Stands for
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        Integer
      </TableCell>

      <TableCell>
        `abn`
      </TableCell>

      <TableCell>
        *abyoone*
      </TableCell>

      <TableCell>
        `abn tirada = 10`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Float
      </TableCell>

      <TableCell>
        `jajab`
      </TableCell>

      <TableCell>
        *jajab*
      </TableCell>

      <TableCell>
        `jajab qiime = 3.14`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        String
      </TableCell>

      <TableCell>
        `qoraal`
      </TableCell>

      <TableCell>
        *qoraal*
      </TableCell>

      <TableCell>
        `qoraal magaca = "Soplang"`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Boolean
      </TableCell>

      <TableCell>
        `bool`
      </TableCell>

      <TableCell>
        *bool*
      </TableCell>

      <TableCell>
        `bool sax = run`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        List
      </TableCell>

      <TableCell>
        `teed`
      </TableCell>

      <TableCell>
        *teed*
      </TableCell>

      <TableCell>
        `teed liis = [1, 2, 3]`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Object
      </TableCell>

      <TableCell>
        `walax`
      </TableCell>

      <TableCell>
        *walax*
      </TableCell>

      <TableCell>
        `walax qof = {magac: "Ali"}`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Constants – madoor [#constants--madoor]

`madoor` (soo gaabinta *madoorsoome*) waxaa loo adeegsadaa qiyamka aan la beddeli karin (immutable).

**constants\_basic.sop**

<SoplangCodeWindow title="constants_basic.sop" code={`madoor magaca = "Soplang"`} />

Constants lama u wareejin karo (reassign):

**constants\_reassign\_error.sop**

<SoplangCodeWindow
  title="constants_reassign_error.sop"
  code={`madoor luqad = "Somali"
luqad = "English"  // Error: cannot reassign constant`}
/>


# Type Conversion

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Type Conversion in Soplang [#type-conversion-in-soplang]

Soplang waxa uu leeyahay shaqooyin-dhexdeed (built-ins) oo fudud oo lagu kala beddelo noocyada xogta. Kuwaas waxay kuu oggolaanayaan inaad si ammaan ah ugu beddesho u dhaxeysa integer, string, decimal, iyo boolean—adigoo ilaalinaya saxnaanta xogta.

nooc() – Type Checking [#nooc--type-checking]

Adeegso `nooc()` si aad u hubiso nooca qiime kasta.

**type\_checking.sop**

<SoplangCodeWindow
  title="type_checking.sop"
  code={`door natiijo = nooc(42)         // "abn"
door natiijo2 = nooc("abc")     // "qoraal"
door natiijo3 = nooc(3.14)      // "jajab"`}
/>

Type Conversion Functions [#type-conversion-functions]

Hoos waxaa ku qoran is-beddellada caanka ah iyo shaqada la adeegsado:

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Conversion
      </TableHead>

      <TableHead>
        Function
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        Int → String
      </TableCell>

      <TableCell>
        `qoraal()`
      </TableCell>

      <TableCell>
        `qoraal(42)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        String → Int
      </TableCell>

      <TableCell>
        `abn()`
      </TableCell>

      <TableCell>
        `abn("123")`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Float → String
      </TableCell>

      <TableCell>
        `qoraal()`
      </TableCell>

      <TableCell>
        `qoraal(3.14)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        String → Float
      </TableCell>

      <TableCell>
        `jajab()`
      </TableCell>

      <TableCell>
        `jajab("3.14")`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Int → Float
      </TableCell>

      <TableCell>
        `jajab()`
      </TableCell>

      <TableCell>
        `jajab(5)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Float → Int
      </TableCell>

      <TableCell>
        `abn()`
      </TableCell>

      <TableCell>
        `abn(4.9)`

         → 

        `4`

         

        *(truncates)*
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        Any → Bool
      </TableCell>

      <TableCell>
        `bool()`
      </TableCell>

      <TableCell>
        `bool(1)`

         → 

        `run`

        , 

        `bool(0)`

         → 

        `been`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Example [#example]

<SoplangCodeWindow
  title="type_conversion_example.sop"
  code={`// Integer to string
abn int_value = 42
qoraal int_str = qoraal(int_value)
qor("Integer to string: " + int_str + " (Type: " + nooc(int_str) + ")")

// String to decimal
qoraal decimal_string = "3.14159"
jajab converted_decimal = jajab(decimal_string)
qor("String to decimal: " + converted_decimal + " (Type: " + nooc(converted_decimal) + ")")

// Decimal to integer (truncation)
jajab decimal_num = 42.75
abn int_from_decimal = abn(decimal_num)
qor("Decimal to integer (truncation): " + int_from_decimal)`}
/>

Shaqooyinkan beddelka noocyadu waxay muhiim u yihiin dhismaha *input-handling* adag, tusaale ahaan marka aad akhrinayso gelinta isticmaalaha ama faylasha oo aad rabto inaad hubiso noocyo sax ah ka hor inta aanad xisaab samayn.


# Operators

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Operators in Soplang [#operators-in-soplang]

Soplang waxa uu taageeraa operators caadi ah oo u eg kuwa luqadaha caanka ah: arithmetic, comparison, iyo logical—si fudud oo akhris-wanaagsan.

Arithmetic Operators [#arithmetic-operators]

Waxaa loo adeegsadaa xisaab tirooyin `abn` ama `jajab`.

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Operator
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `+`
      </TableCell>

      <TableCell>
        Addition
      </TableCell>

      <TableCell>
        `a + b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `-`
      </TableCell>

      <TableCell>
        Subtraction
      </TableCell>

      <TableCell>
        `a - b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `*`
      </TableCell>

      <TableCell>
        Multiplication
      </TableCell>

      <TableCell>
        `a * b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `/`
      </TableCell>

      <TableCell>
        Division
      </TableCell>

      <TableCell>
        `a / b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `%`
      </TableCell>

      <TableCell>
        Modulo
      </TableCell>

      <TableCell>
        `a % b`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

<SoplangCodeWindow
  title="arithmetic_operators.sop"
  code={`abn a = 10
abn b = 3
qor("Wadarta: " + (a + b))
qor("Hadhaaga: " + (a % b))`}
/>

Comparison Operators [#comparison-operators]

Lagu hubiyo isbarbar dhig ama sinnaansho u dhexeeya qiimeyaal.

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Operator
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `==`
      </TableCell>

      <TableCell>
        Equal
      </TableCell>

      <TableCell>
        `a == b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `!=`
      </TableCell>

      <TableCell>
        Not equal
      </TableCell>

      <TableCell>
        `a != b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `>`
      </TableCell>

      <TableCell>
        Greater than
      </TableCell>

      <TableCell>
        `a > b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `<`
      </TableCell>

      <TableCell>
        Less than
      </TableCell>

      <TableCell>
        `a < b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `>=`
      </TableCell>

      <TableCell>
        Greater or equal
      </TableCell>

      <TableCell>
        `a >= b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `<=`
      </TableCell>

      <TableCell>
        Less or equal
      </TableCell>

      <TableCell>
        `a <= b`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

<SoplangCodeWindow
  title="comparison_operators.sop"
  code={`door a = 5
door b = 10
qor("a == b: " + (a == b))
qor("a < b: " + (a < b))`}
/>

Logical Operators [#logical-operators]

Waxaa loo adeegsadaa isku-darka xaaladaha (conditions) boolean.

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Operator
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `&&`
      </TableCell>

      <TableCell>
        Logical AND
      </TableCell>

      <TableCell>
        `(a > 5) && (b < 10)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `||`
      </TableCell>

      <TableCell>
        Logical OR
      </TableCell>

      <TableCell>
        `(a < 5) || (b > 3)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `!`
      </TableCell>

      <TableCell>
        Logical NOT
      </TableCell>

      <TableCell>
        `!(a == b)`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

<SoplangCodeWindow
  title="logical_operators.sop"
  code={`abn x = 5
abn y = 10

bool isInRange = (x > 3) && (y < 15)
bool isMismatch = !(x == y)
qor("Is in range: " + isInRange)
qor("Mismatch: " + isMismatch)`}
/>

Operators-ka Soplang waxay kuu oggolaanayaan inaad dhisto muujiyeyo awood leh iyo xakamayn (control flow) nadiif ah.


# Conditional Statements

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Conditional Statements [#conditional-statements]

Soplang waxay bixisaa fulin shuruudeed (conditional execution) iyadoo adeegsanaysa erayo Soomaali ah si ay u noqoto mid cad oo muujin leh.

If Statements – haddii, haddii_kale, ugudambeyn [#if-statements--haddii-haddii_kale-ugudambeyn]

Waxay u dhigmaan *if*, *else if*, iyo *else* luqadaha kale.

<SoplangCodeWindow
  title="if_statements.sop"
  code={`abn da = 17

haddii (da >= 18) {
  qor("Waad qaan gaadhay")
} haddii_kale (da >= 13) {
  qor("Waxaad tahay dhallinyaro")
} ugudambeyn {
  qor("Waad yar tahay")
}`}
/>

Block walba waxaa lagu xiraa `{}`. Waxaad isku xirin ama isku dhex dhigi kartaa (nest) sidaad u baahan tahay.

Boolean Conditions [#boolean-conditions]

Adeegso muujiyeyaasha `bool` iyo operators-ka `&&`, `||`, iyo `!`.

<SoplangCodeWindow
  title="boolean_conditions.sop"
  code={`abn x = 4
abn y = 9

haddii (x < y && y < 10) {
  qor("Shuruudaha waa sax")
}

// Negation
haddii (!(x == y)) {
  qor("Qiimuhu ma sina")
}`}
/>

Summary [#summary]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `haddii`
      </TableCell>

      <TableCell>
        if
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `haddii_kale`
      </TableCell>

      <TableCell>
        else if
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `ugudambeyn`
      </TableCell>

      <TableCell>
        else
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Control flow ee Soplang wuxuu raacaa qaab akhris-wanaagsan oo Somali-first ah.

Switch-Case – dooro iyo xaalad [#switch-case--dooro-iyo-xaalad]

Loogu talagalay laanayn cad oo ku saleysan hal qiime: `dooro` (switch expression), `xaalad` (case), iyo `ugudambeyn` (default).

<SoplangCodeWindow
  title="switch_case.sop"
  code={`qoraal maalinta = "Jimce"

dooro (maalinta) {
  xaalad "Isniin" {
      qor("Todobaad cusub")
  }
  xaalad "Jimce" {
      qor("Waqti nasasho")
  }
  ugudambeyn {
      qor("Maalin kale")
  }
}`}
/>

Tani waxay ku habboon tahay go'aan-qaadasho leh laamo badan oo ku saleysan qiime go'an.

Combined Usage [#combined-usage]

Waxaad isku dari kartaa `haddii`/`haddii_kale`/`ugudambeyn` iyo `dooro` si aad u dhisto logic adag oo weli akhris-wanaagsan.


# Loops

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Loops in Soplang [#loops-in-soplang]

Soplang waxa uu taageeraa laba nooc oo loops ah: `intay (shuruud)` oo u dhiganta *while*, iyo `kuceli (bilow ilaa dhamaad)` oo u dhiganta *for*. Waxa kale oo jira `jooji` (break) iyo `soco` (continue) si aad u yeelato xakameyn faahfaahsan.

While Loop – intay [#while-loop--intay]

Koodhka ku jira block-ga wuu soconayaa inta shuruuddu tahay *run*:

**while\_basic.sop**

<SoplangCodeWindow
  title="while_basic.sop"
  code={`abn i = 1
intay (i <= 5) {
  qor("i = " + i)
  i = i + 1
}`}
/>

Waxay taageertaa `jooji` iyo `soco`:

**while\_break\_continue.sop**

<SoplangCodeWindow
  title="while_break_continue.sop"
  code={`abn i = 0
intay (i <= 10) {
  i = i + 1

  haddii (i % 2 == 0) {
      soco        // ka bood tirooyinka labiska ah
  }

  haddii (i == 7) {
      jooji        // jooji loop-ka marka i = 7
  }

  qor("i = " + i) // waxay daabacdaa: 1, 3, 5
}`}
/>

For Loop – kuceli [#for-loop--kuceli]

**for\_basic.sop**

<SoplangCodeWindow
  title="for_basic.sop"
  code={`kuceli (i 1 ilaa 5) {
  qor("Tirada: " + i)
}`}
/>

Talaabo (step) la doortay:

**for\_step.sop**

<SoplangCodeWindow
  title="for_step.sop"
  code={`kuceli (j 2 ilaa 10 :: 2) {
  qor("Step: " + j)
}`}
/>

Loop Over List [#loop-over-list]

**loop\_over\_list.sop**

<SoplangCodeWindow
  title="loop_over_list.sop"
  code={`teed numbers = [10, 20, 30]
kuceli (i 0 ilaa numbers.dherer() - 1) {
  qor("Element " + i + ": " + numbers[i])
}`}
/>

Nested Loops [#nested-loops]

**nested\_loops.sop**

<SoplangCodeWindow
  title="nested_loops.sop"
  code={`kuceli (i 1 ilaa 3) {
  intay (i > 0) {
      qor("Nested example")
      jooji
  }
}`}
/>

Factorial with While [#factorial-with-while]

**factorial\_while.sop**

<SoplangCodeWindow
  title="factorial_while.sop"
  code={`abn a = 5
abn result = 1
abn n = a

intay (n > 0) {
  result = result * n
  n = n - 1
}
qor(result)`}
/>

Summary [#summary]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `intay`
      </TableCell>

      <TableCell>
        while loop
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `kuceli`
      </TableCell>

      <TableCell>
        for loop
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `jooji`
      </TableCell>

      <TableCell>
        break
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `soco`
      </TableCell>

      <TableCell>
        continue
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Soplang loops waxay taageeraan labadaba ku-celcelin qaabaysan iyo socod ku saleysan shuruud.


# Functions

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Functions in Soplang [#functions-in-soplang]

Functions (hawlo) waa qaybo koodh oo dib loo isticmaali karo. Soplang waxa lagu qeexaa `hawl` waxaana natiijo lagu soo celinayaa `celi`.

Define a Function – hawl [#define-a-function--hawl]

Hawl waxa ay bilaabataa `hawl` kadibna magac hawl iyo parameters (aan lahayn type annotations).

<SoplangCodeWindow
  title="define_function.sop"
  code={`hawl salaan(magac) {
  qor("Asalaamu calaykum, " + magac)
}`}
/>

Call a Function [#call-a-function]

Marka aad qeexdo, ku wac magaceeda oo raaci doodaha (arguments):

<SoplangCodeWindow title="call_function.sop" code={`salaan("Aamina")`} />

Return Values – celi [#return-values--celi]

Adeegso `celi` si aad uga soo celiso hawl qiime.

<SoplangCodeWindow
  title="return_values.sop"
  code={`hawl labanlaab(x) {
  celi x * 2
}

abn natiijo = labanlaab(5)
qor("Natiijo: " + natiijo)`}
/>

Loops Inside Functions [#loops-inside-functions]

Hawluhu waxay ka kooban karaan loops iyo logic kale sida blocks-ka caadiga ah.

<SoplangCodeWindow
  title="loops_inside_functions.sop"
  code={`hawl muujin(liis) {
  kuceli (i 0 ilaa liis.dherer() - 1) {
      qor("Liiska: " + liis[i])
  }
}`}
/>

Summary [#summary]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `hawl`
      </TableCell>

      <TableCell>
        function definition
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `celi`
      </TableCell>

      <TableCell>
        return value
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Functions ee Soplang waxay ka dhigaan koodhka dib-u-isticmaal leh, nadiif, oo Somali-first.


# Data Types

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Data Types in Soplang [#data-types-in-soplang]

Soplang waxa uu leeyahay noocyo xog oo kala duwan si uu u metelo qiimeyaal kala geddisan. Boggan waxa uu daboolayaa noocyada aasaasiga ah (primitives) iyo ururinta (collections) iyo sida ugu habboon ee loo isticmaalo.

Primitive Types [#primitive-types]

Kuwaani waa noocyada ugu aasaasiga ah ee dhisaya noocyada kale ee adag.

Numbers [#numbers]

Soplang waxa uu taageeraa tirooyinka dhan iyo jajab. Waxa aad isticmaali kartaa `door` (dynamic) ama `abn` (static).

**numbers.sop**

<SoplangCodeWindow
  title="numbers.sop"
  code={`// Dynamic typing
door lambarka1 = 42       // Integer
door lambarka2 = 3.14     // Floating-point

// Static typing
abn lambarka3 = 100       // Integer
abn lambarka4 = -25       // Negative integer

// Arithmetic
qor(lambarka1 + lambarka2)   // 45.14
qor(lambarka1 * lambarka3)   // 4200
qor(lambarka3 / lambarka1)   // 2.38...`}
/>

Strings [#strings]

*Strings* waa taxane xarfo ah. Waxaad adeegsan kartaa q-double ama q-single, ka dibna ku shaqayn karaan habab kala duwan.

**strings.sop**

<SoplangCodeWindow
  title="strings.sop"
  code={`// Dynamic typing
door magac1 = "Soplang"
door magac2 = 'Programming Language'

// Static typing
qoraal magac3 = "Soplang: Luuqadda Barnaamijyada ee Afka Soomaaliga"

// Concatenation
qor(magac1 + " - " + magac2)   // Soplang - Programming Language

// Dherer & habab
qor(magac1.dherer())           // 7
qor(magac1.sareyn())           // SOPLANG
qor(magac1.hooseyn())          // soplang
qor(magac3.qayb(0, 7))         // Soplang

// Interpolation (haddii ay taageerto f-strings)
door version = 2.0
qor(f"{magac1} v{version}")    // Soplang v2.0`}
/>

Booleans [#booleans]

Qiimayaasha run/been: `run` iyo `been`. Waxaad adeegsan kartaa `door` ama `bool`.

**booleans.sop**

<SoplangCodeWindow
  title="booleans.sop"
  code={`// Dynamic typing
door waa_sax = run
door waa_qalad = been

// Static typing
bool waa_arday = run
bool waa_macalin = been

// Logical
qor(waa_sax && waa_qalad)  // false
qor(waa_sax || waa_qalad)  // true
qor(!waa_sax)              // false

// Comparison
door x = 10
door y = 20
qor(x > y)     // false
qor(x <= y)    // true
qor(x == 10)   // true
qor(x != y)    // true`}
/>

Collection Types [#collection-types]

Ururinta waxa ay kuu oggolaanayaan in aad isku kaydiso qiimeyaal badan.

Lists [#lists]

Liisaska waa ururin leh amar (ordered). Waad abuuri kartaa adigoo adeegsanaya `teed` (static) ama `door` oo leh `[]`.

**lists.sop**

<SoplangCodeWindow
  title="lists.sop"
  code={`// Abuurista liis
door tiro = [1, 2, 3, 4, 5]
teed magacyada = ["Cabdi", "Caasha", "Xasan", "Hodan"]
teed isku_dhafan = [1, "Soplang", run, 3.14]

// Helidda walxaha (zero-indexed)
qor(tiro[0])         // 1
qor(magacyada[2])    // Xasan

// Beddelid
tiro[0] = 10
qor(tiro)            // [10, 2, 3, 4, 5]

// Hababka liisaska
tiro.kudar(6)        // ku dar dhamaadka
qor(tiro)            // [10, 2, 3, 4, 5, 6]

magacyada.saar(1)    // ka saar index 1
qor(magacyada)       // ["Cabdi", "Xasan", "Hodan"]

// Dherer
qor(magacyada.dherer())  // 3`}
/>

Objects (Dictionaries) [#objects-dictionaries]

*Objects* waa lammaane fure–qiime ah. Waxaad ku abuuri kartaa `door` adigoo adeegsanaya `{}` ama nooca static ee `walax`.

**objects.sop**

<SoplangCodeWindow
  title="objects.sop"
  code={`// Abuurista objects
door qof = {
"magac": "Cabdilaahi",
"da": 25,
"waa_arday": run
}

walax luuqad = {
"magac": "Soplang",
"version": 2.0,
"sanadka": 2023,
"features": ["OOP", "Dynamic Typing", "Easy Syntax"]
}

// Helidda qiimeyaal
qor(qof["magac"])       // Cabdilaahi
qor(luuqad["version"])  // 2.0

// Dot-notation (haddii la taageero)
qor(qof.magac)          // Cabdilaahi
qor(luuqad.features)    // ["OOP", "Dynamic Typing", "Easy Syntax"]

// Beddelid
qof["da"] = 26
qof["degaan"] = "Muqdisho"
qor(qof)

// Hubi furaha
qor("magac" ku dhex jira qof)   // true
qor("luuqad" ku dhex jira qof)  // false

// Habab
qor(qof.fureyaasha())    // ["magac", "da", "waa_arday", "degaan"]
qor(qof.qiimeyaasha())   // ["Cabdilaahi", 26, true, "Muqdisho"]
qor(luuqad.dherer())     // 4`}
/>


# Strings in Soplang

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Strings in Soplang [#strings-in-soplang]

Soplang waxa uu taageeraa habab kala duwan oo *string* manipulation ah oo leh magacyo Soomaali u-dhega nugul. Strings waxaa lagu qeexaa `door` ama `qoraal`.

Declare a String [#declare-a-string]

<SoplangCodeWindow
  title="declare_string.sop"
  code={`qoraal magac = "Sharafdin Yusuf"
door farriin = "Ku soo dhowow Soplang"`}
/>

String Methods [#string-methods]

Hababka hoose waxay ka tarjumayaan kuwa caanka ah ee luqadaha kale, balse magacyo Soomaali ah ayay leeyihiin:

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Method
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Description
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `qeybi(xad)`
      </TableCell>

      <TableCell>
        `split()`
      </TableCell>

      <TableCell>
        Kala jabiso string iyadoo la adeegsanayo kala-sooc.
      </TableCell>

      <TableCell>
        `door parts = text.qeybi(",")`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `leeyahay(sub)`
      </TableCell>

      <TableCell>
        `includes()`
      </TableCell>

      <TableCell>
        Hubi in uu ku jiro far-qoraal gaaban.
      </TableCell>

      <TableCell>
        `haddii (text.leeyahay("search")) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `dhamaad(sub)`
      </TableCell>

      <TableCell>
        `endsWith()`
      </TableCell>

      <TableCell>
        Hubi in uu ku dhammaado far-qoraal.
      </TableCell>

      <TableCell>
        `haddii (text.dhamaad("ing")) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `bilow(sub)`
      </TableCell>

      <TableCell>
        `startsWith()`
      </TableCell>

      <TableCell>
        Hubi in uu ku bilaabmo far-qoraal.
      </TableCell>

      <TableCell>
        `haddii (text.bilow("http")) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `beddel(x, y)`
      </TableCell>

      <TableCell>
        `replace()`
      </TableCell>

      <TableCell>
        Beddel 

        *x*

         adigoo u beddelaya 

        *y*

        .
      </TableCell>

      <TableCell>
        `door cusub = text.beddel("old", "new")`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `kudar(teed)`
      </TableCell>

      <TableCell>
        `join()`
      </TableCell>

      <TableCell>
        Ku xiro liis xarfo adigoo isticmaalaya kala-soocan.
      </TableCell>

      <TableCell>
        `door text = ", ".kudar(names)`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `jar(bilow, dhamaad)`
      </TableCell>

      <TableCell>
        `slice()`
      </TableCell>

      <TableCell>
        Soo saar qayb ka timid 

        *bilow*

         ilaa 

        *dhamaad*

        .
      </TableCell>

      <TableCell>
        `door sub = text.jar(0, 3)`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Example Usage [#example-usage]

<SoplangCodeWindow
  title="strings_example_usage.sop"
  code={`qoraal jumlad = "Soplang waa luqad qurux badan"

// Split string into parts
teed ereyo = jumlad.qeybi(" ")
qor("Ereyada: " + ereyo)

// Check if it contains a word
haddii (jumlad.leeyahay("luqad")) {
  qor("Waa luqad!")
}

// Starts and ends with
haddii (jumlad.bilow("Soplang")) {
  qor("Waxay ku bilaabataa Soplang")
}

haddii (jumlad.dhamaad("badan")) {
  qor("Waxay ku dhammaanaysaa badan")
}

// Replace word
door beddelay = jumlad.beddel("luqad", "barnaamij")
qor("Beddelay: " + beddelay)

// Join string from list
teed magacyo = ["Ayaan", "Omar", "Zahra"]
door joined = ", ".kudar(magacyo)
qor("Dad: " + joined)

// Slice part of string
door qeyb = jumlad.jar(0, 7)
qor("Qeybta koowaad: " + qeyb)`}
/>

Strings ee Soplang waa muujin iyo la-qabsan fudud, iyadoo magacyada hababka ay yihiin Soomaali-first si ay u noqdaan kuwo si dabiici ah loo fahmo.


# Numbers

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Numbers in Soplang [#numbers-in-soplang]

Soplang waxa uu leeyahay laba nooc oo tiro ah: **abn** (integers) iyo **jajab** (decimals). Boggan waxa uu muujinayaa sida loo qoro, loo xisaabiyo, loona is-beddelo labadan nooc.

Integers — abn [#integers--abn]

`abn` waxa uu metelaa tirooyin dhan (…,-2,-1,0,1,2,…). Waxaad qeexi kartaa si *dynamic* (`door`) ama si *static* (`abn`).

<SoplangCodeWindow
  title="integers.sop"
  code={`// Literals & declaration
abn da = 21
door tirin = 100     // dynamic, but integer value

// Arithmetic
abn a = 10
abn b = 3
qor(a + b)   // 13
qor(a - b)   // 7
qor(a * b)   // 30
qor(a / b)   // 3.333...  (natiijo jajab ah)
qor(a % b)   // 1         (remainder)

// Comparisons
qor(a > b)    // run
qor(a == 10)  // run
qor(a != b)   // run`}
/>

Qaybintu (`/`) waxay bixin kartaa natiijo *jajab* haddii aysan si buuxda u qaybsamin—haddii aad rabto integer oo keliya, isticmaal `abn()` si aad u *truncation* sameyso.

<SoplangCodeWindow title="integer_truncation.sop" code={`abn natiijo_dhan = abn(10 / 3)  // 3 (truncation)`} />

Decimals — jajab [#decimals--jajab]

`jajab` waxa uu metelaa tirooyinka leh meel-dhaaf (floating/decimal). Waxaa ku habboon xisaab sax ah oo leh jajab.

<SoplangCodeWindow
  title="decimals.sop"
  code={`// Literals & declaration
jajab pi = 3.14159
door qiime = 2.5       // dynamic, decimal value

// Arithmetic
jajab x = 10.0
jajab y = 4.0
qor(x + y)   // 14.0
qor(x - y)   // 6.0
qor(x * y)   // 40.0
qor(x / y)   // 2.5

// Comparisons
qor(pi > 3)        // run
qor(2.0 == 2)      // run (labaduba waxay loo turjumi karaa qiime isu eg)`}
/>

Haddii aad ka timid `door` oo aadan hubin nooca, waxaad ka fiirsan kartaa `nooc()` si aad u xaqiijiso.

<SoplangCodeWindow
  title="check_decimal_type.sop"
  code={`door n = 2.75
qor(nooc(n))  // "jajab"`}
/>

Isku-darka abn & jajab [#isku-darka-abn--jajab]

Marka aad isku qasto `abn` iyo `jajab`, natiijadu inta badan waxay noqotaa `jajab`. Waxaad si cad u qasbi kartaa nooca adigoo adeegsanaya `abn()` ama `jajab()`.

<SoplangCodeWindow
  title="mixing_abn_jajab.sop"
  code={`abn a = 5
jajab b = 2.0

// Natiijo jajab
door c = a + b
qor(c)          // 7.0
qor(nooc(c))    // "jajab"

// Qasbi integer (truncation)
abn d = abn(a / b)
qor(d)          // 2

// Qasbi decimal
jajab e = jajab(a * 2)
qor(e)          // 10.0`}
/>

Beddel & xaqiijin degdeg ah [#beddel--xaqiijin-degdeg-ah]

<SoplangCodeWindow
  title="numbers_quick_check.sop"
  code={`// From input → number
door gelin_da = gelin("Da'daada qor: ")
abn da = abn(gelin_da)               // "19" -> 19
qor("Nooc: " + nooc(da))             // "abn"

// String → decimal
jajab qiime = jajab("12.75")
qor(qiime + 0.25)                    // 13.0

// Number → string
qoraal s = qoraal(2025)
qor("Sanad: " + s)`}
/>


# Arrays

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Arrays [#arrays]

Arrays waxa lagu qeexaa erayga `teed`. Waxay hayaan uruurin qiimayaal ah oo leh habab badan: maarayn, beddelid, iyo falanqayn.

Declaring Arrays [#declaring-arrays]

<SoplangCodeWindow
  title="arrays_declaring.sop"
  code={`teed numbers = [1, 2, 3, 4]
teed magacyo = ["Ali", "Zahra"]`}
/>

Core Array Methods [#core-array-methods]

dherer() – Get Length [#dherer--get-length]

<SoplangCodeWindow
  title="arrays_length.sop"
  code={`teed x = [10, 20, 30]
qor("Length: " + x.dherer())  // 3`}
/>

kudar(x) – Add to End [#kudarx--add-to-end]

<SoplangCodeWindow
  title="arrays_push.sop"
  code={`teed x = [1, 2]
x.kudar(3)   // [1, 2, 3]
x.kudar(4)   // [1, 2, 3, 4]`}
/>

kasaar() – Remove Last [#kasaar--remove-last]

<SoplangCodeWindow
  title="arrays_pop.sop"
  code={`door last = x.kasaar()
qor("Removed: " + last)`}
/>

kudar(teed) – Concatenate [#kudarteed--concatenate]

<SoplangCodeWindow
  title="arrays_concat.sop"
  code={`teed a = [1, 2]
teed b = [3, 4]
teed c = a.kudar(b)    // [1, 2, 3, 4]`}
/>

leeyahay(x) – Contains Check [#leeyahayx--contains-check]

<SoplangCodeWindow
  title="arrays_contains.sop"
  code={`haddii (c.leeyahay(3)) {
  qor("Waa jiraa")
}`}
/>

Utility Methods [#utility-methods]

nuqul() – Copy Array [#nuqul--copy-array]

<SoplangCodeWindow
  title="arrays_copy.sop"
  code={`teed asal = [10, 20]
teed copy = asal.nuqul()
qor("Copy: " + copy)`}
/>

rog() – Reverse [#rog--reverse]

<SoplangCodeWindow
  title="arrays_reverse.sop"
  code={`asal.rog()
qor("Reversed: " + asal)`}
/>

nadiifi() – Clear [#nadiifi--clear]

<SoplangCodeWindow
  title="arrays_clear.sop"
  code={`copy.nadiifi()
qor("Emptied copy: " + copy)`}
/>

habee() – Sort [#habee--sort]

<SoplangCodeWindow
  title="arrays_sort.sop"
  code={`teed t = [4, 2, 3]
t.habee()
qor("Sorted: " + t)`}
/>

Transform and Filter [#transform-and-filter]

aaddin(funk) – Map Items [#aaddinfunk--map-items]

<SoplangCodeWindow
  title="arrays_map.sop"
  code={`hawl laban(x) {
  celi x * 2
}

teed nums = [1, 2, 3]
teed doubled = nums.aaddin("laban")`}
/>

shaandhee(funk) – Filter Items [#shaandheefunk--filter-items]

<SoplangCodeWindow
  title="arrays_filter.sop"
  code={`hawl is_even(x) {
  celi x % 2 == 0
}

teed filtered = nums.shaandhee("is_even")`}
/>

Indexing and Slicing [#indexing-and-slicing]

muuji(x) – Find Index [#muujix--find-index]

<SoplangCodeWindow
  title="arrays_index_of.sop"
  code={`abn i = nums.muuji(2)
qor("Index of 2: " + i)`}
/>

jar(a, b) – Slice Sublist [#jara-b--slice-sublist]

<SoplangCodeWindow
  title="arrays_slice.sop"
  code={`teed subset = nums.jar(1, 3)
qor("Subset: " + subset)`}
/>

**Gunaanad:** `teed` waa qaab-dhismeed aasaasi ah oo Soo-maali-first ah, fududeynaaya maaraynta iyo ku celcelinta liisaska.


# Objects in Soplang

   

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Objects in Soplang [#objects-in-soplang]

Objects in Soplang are defined using the `walax` type. They store key–value pairs and provide Somali-first methods to inspect, modify, and copy structured data.

🧾 Declaring an Object – walax [#-declaring-an-object--walax]

**declare\_object.sop**

<SoplangCodeWindow
  title="declare_object.sop"
  code={`walax qof = {
  magac: "Ayaan",
  da: 25,
  shaqo: "barayaal"
}`}
/>

🔧 Core Object Methods [#-core-object-methods]

fure() – Get Keys [#fure--get-keys]

**keys.sop**

<SoplangCodeWindow
  title="keys.sop"
  code={`door keys = qof.fure()
qor(keys)`}
/>

qiime() – Get Values [#qiime--get-values]

**values.sop**

<SoplangCodeWindow
  title="values.sop"
  code={`door values = qof.qiime()
qor(values)`}
/>

lamaane() – Get Key-Value Pairs [#lamaane--get-key-value-pairs]

**pairs.sop**

<SoplangCodeWindow
  title="pairs.sop"
  code={`door pairs = qof.lamaane()
qor(pairs)`}
/>

leeyahay(x) – Has Key [#leeyahayx--has-key]

**has\_key.sop**

<SoplangCodeWindow
  title="has_key.sop"
  code={`haddii (qof.leeyahay("magac")) {
  qor("Magaca wuu jiraa")
}`}
/>

tir(x) – Delete Key [#tirx--delete-key]

**delete.sop**

<SoplangCodeWindow
  title="delete.sop"
  code={`qof.tir("shaqo")
qor(qof)`}
/>

kudar(obj) – Merge/Assign [#kudarobj--mergeassign]

**merge.sop**

<SoplangCodeWindow
  title="merge.sop"
  code={`walax A = {x: 1}
walax B = {y: 2}
walax C = A.kudar(B)

qor(C)  // {x: 1, y: 2}`}
/>

nuqul() – Copy [#nuqul--copy]

**copy.sop**

<SoplangCodeWindow
  title="copy.sop"
  code={`walax asal = {a: 10, b: 20}
walax copy = asal.nuqul()
qor(copy)`}
/>

nadiifi() – Clear All Properties [#nadiifi--clear-all-properties]

**clear.sop**

<SoplangCodeWindow
  title="clear.sop"
  code={`asal.nadiifi()
qor("Cleared object: " + asal)`}
/>

**Gunaanad:** `walax` waxay siisaa qaab awood badan oo lagu kaydiyo xog magacyo leh, iyadoo leh habab si buuxda ugu qoran Af-Soomaali.


# Soplang Keywords Reference

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Soplang Keywords Reference [#soplang-keywords-reference]

Dukumeentigani waxa uu soo koobayaa ereyada (keywords) ee Soplang, macnahooda, u dhigmaha Ingiriisiga, iyo tusaalooyin isticmaal.

Variable Declaration Keywords [#variable-declaration-keywords]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `door`
      </TableCell>

      <TableCell>
        Dynamic variable declaration
      </TableCell>

      <TableCell>
        `var/let`
      </TableCell>

      <TableCell>
        `door magac = "Sharafdin"`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `madoor`
      </TableCell>

      <TableCell>
        Constant variable declaration
      </TableCell>

      <TableCell>
        `const`
      </TableCell>

      <TableCell>
        `madoor PI = 3.14159`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `abn`
      </TableCell>

      <TableCell>
        Integer type
      </TableCell>

      <TableCell>
        `int`
      </TableCell>

      <TableCell>
        `abn da = 25`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `jajab`
      </TableCell>

      <TableCell>
        Decimal/float type
      </TableCell>

      <TableCell>
        `float/double`
      </TableCell>

      <TableCell>
        `jajab qiimo = 3.14`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `qoraal`
      </TableCell>

      <TableCell>
        String type
      </TableCell>

      <TableCell>
        `string`
      </TableCell>

      <TableCell>
        `qoraal magac = "Sharafdin"`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `bool`
      </TableCell>

      <TableCell>
        Boolean type
      </TableCell>

      <TableCell>
        `bool`
      </TableCell>

      <TableCell>
        `bool waaRun = run`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `walax`
      </TableCell>

      <TableCell>
        Object type
      </TableCell>

      <TableCell>
        `object`
      </TableCell>

      <TableCell>
        `walax person = { name: "Sharafdin" }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `teed`
      </TableCell>

      <TableCell>
        List/array type
      </TableCell>

      <TableCell>
        `array`
      </TableCell>

      <TableCell>
        `teed numbers = [1, 2, 3]`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `maran`
      </TableCell>

      <TableCell>
        Null value
      </TableCell>

      <TableCell>
        `null`
      </TableCell>

      <TableCell>
        `door a = maran`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Control Flow Keywords [#control-flow-keywords]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `haddii`
      </TableCell>

      <TableCell>
        If statement
      </TableCell>

      <TableCell>
        `if`
      </TableCell>

      <TableCell>
        `haddii (x > 10) { qor("Weyn") }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `haddii_kale`
      </TableCell>

      <TableCell>
        Else if statement
      </TableCell>

      <TableCell>
        `else if`
      </TableCell>

      <TableCell>
        `haddii_kale (x == 10) { qor("Dhexe") }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `ugudambeyn`
      </TableCell>

      <TableCell>
        Else statement
      </TableCell>

      <TableCell>
        `else`
      </TableCell>

      <TableCell>
        `ugudambeyn { qor("Yar") }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `dooro`
      </TableCell>

      <TableCell>
        Switch statement
      </TableCell>

      <TableCell>
        `switch`
      </TableCell>

      <TableCell>
        `dooro (x) { xaalad 1 { qor("Hal") } }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `xaalad`
      </TableCell>

      <TableCell>
        Case clause
      </TableCell>

      <TableCell>
        `case`
      </TableCell>

      <TableCell>
        `xaalad "A" { qor("Case A") }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `kuceli`
      </TableCell>

      <TableCell>
        For loop
      </TableCell>

      <TableCell>
        `for`
      </TableCell>

      <TableCell>
        `kuceli (i 1 ilaa 5) { qor(i) }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `ilaa`
      </TableCell>

      <TableCell>
        Loop range end
      </TableCell>

      <TableCell>
        `to`
      </TableCell>

      <TableCell>
        `kuceli (i 1 ilaa 5) { qor(i) }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `::`
      </TableCell>

      <TableCell>
        Loop increment
      </TableCell>

      <TableCell>
        `step`
      </TableCell>

      <TableCell>
        `kuceli (i 1 ilaa 10 :: 2) { qor(i) }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `intay`
      </TableCell>

      <TableCell>
        While loop
      </TableCell>

      <TableCell>
        `while`
      </TableCell>

      <TableCell>
        `intay (x < 5) { qor(x) }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `jooji`
      </TableCell>

      <TableCell>
        Break statement
      </TableCell>

      <TableCell>
        `break`
      </TableCell>

      <TableCell>
        `haddii (x == 3) { jooji }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `soco`
      </TableCell>

      <TableCell>
        Continue statement
      </TableCell>

      <TableCell>
        `continue`
      </TableCell>

      <TableCell>
        `haddii (x == 3) { soco }`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Function Keywords [#function-keywords]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Keyword
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `hawl`
      </TableCell>

      <TableCell>
        Function declaration
      </TableCell>

      <TableCell>
        `function`
      </TableCell>

      <TableCell>
        `hawl isuGee(a, b) { celi a + b }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `celi`
      </TableCell>

      <TableCell>
        Return statement
      </TableCell>

      <TableCell>
        `return`
      </TableCell>

      <TableCell>
        `celi x * 2`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Special Values [#special-values]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Somali Value
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Description
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `run`
      </TableCell>

      <TableCell>
        `true`
      </TableCell>

      <TableCell>
        Boolean true value
      </TableCell>

      <TableCell>
        `haddii (run) { ... }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `been`
      </TableCell>

      <TableCell>
        `false`
      </TableCell>

      <TableCell>
        Boolean false value
      </TableCell>

      <TableCell>
        `haddii (!been) { ... }`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `maran`
      </TableCell>

      <TableCell>
        `null`
      </TableCell>

      <TableCell>
        Empty/null value
      </TableCell>

      <TableCell>
        `door val = maran`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Operators [#operators]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Somali Operator
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Description
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell>
        `+`
      </TableCell>

      <TableCell>
        `+`
      </TableCell>

      <TableCell>
        Addition
      </TableCell>

      <TableCell>
        `x = a + b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `-`
      </TableCell>

      <TableCell>
        `-`
      </TableCell>

      <TableCell>
        Subtraction
      </TableCell>

      <TableCell>
        `x = a - b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `*`
      </TableCell>

      <TableCell>
        `*`
      </TableCell>

      <TableCell>
        Multiplication
      </TableCell>

      <TableCell>
        `x = a * b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `/`
      </TableCell>

      <TableCell>
        `/`
      </TableCell>

      <TableCell>
        Division
      </TableCell>

      <TableCell>
        `x = a / b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `%`
      </TableCell>

      <TableCell>
        `%`
      </TableCell>

      <TableCell>
        Modulo
      </TableCell>

      <TableCell>
        `x = a % b`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `==`
      </TableCell>

      <TableCell>
        `==`
      </TableCell>

      <TableCell>
        Equal to
      </TableCell>

      <TableCell>
        `haddii (a == b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `!=`
      </TableCell>

      <TableCell>
        `!=`
      </TableCell>

      <TableCell>
        Not equal to
      </TableCell>

      <TableCell>
        `haddii (a != b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `>`
      </TableCell>

      <TableCell>
        `>`
      </TableCell>

      <TableCell>
        Greater than
      </TableCell>

      <TableCell>
        `haddii (a > b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `<`
      </TableCell>

      <TableCell>
        `<`
      </TableCell>

      <TableCell>
        Less than
      </TableCell>

      <TableCell>
        `haddii (a < b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `>=`
      </TableCell>

      <TableCell>
        `>=`
      </TableCell>

      <TableCell>
        Greater than or equal to
      </TableCell>

      <TableCell>
        `haddii (a >= b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `<=`
      </TableCell>

      <TableCell>
        `<=`
      </TableCell>

      <TableCell>
        Less than or equal to
      </TableCell>

      <TableCell>
        `haddii (a <= b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `&&`
      </TableCell>

      <TableCell>
        `&&`
      </TableCell>

      <TableCell>
        Logical AND
      </TableCell>

      <TableCell>
        `haddii (a && b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `||`
      </TableCell>

      <TableCell>
        `||`
      </TableCell>

      <TableCell>
        Logical OR
      </TableCell>

      <TableCell>
        `haddii (a || b) {...}`
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell>
        `!`
      </TableCell>

      <TableCell>
        `!`
      </TableCell>

      <TableCell>
        Logical NOT
      </TableCell>

      <TableCell>
        `haddii (!a) {...}`
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

Quick Examples [#quick-examples]

**keywords\_quick\_examples.sop**

<SoplangCodeWindow
  title="keywords_quick_examples.sop"
  code={`// Variables
door magac = "Sharafdin"
madoor PI = 3.14159
abn da = 25
jajab qiimo = 3.14
qoraal qora = "Salaan"
bool sax = run
teed numbers = [1, 2, 3]
walax qof = { magac: "Ayaan" }
door wax = maran

// Control flow
haddii (da >= 18) { qor("Qof weyn") } ugudambeyn { qor("Ilmo") }

dooro (qora) {
xaalad "Salaan" { qor("Hello!") }
ugudambeyn { qor("Unknown") }
}

kuceli (i 1 ilaa 5 :: 2) { qor(i) }
abn x = 1
intay (x < 3) { qor(x); x = x + 1 }

// Functions
hawl isuGee(a, b) { celi a + b }
qor(isuGee(2, 3))`}
/>


# Built-in Functions in Soplang

   

import {
  Table,
  TableBody,
  TableCaption,
  TableCell,
  TableFooter,
  TableHead,
  TableHeader,
  TableRow,
} from "../../components/ui/table";

import SoplangCodeWindow from "../../components/SoplangCodeWindow";

Built-in Functions in Soplang [#built-in-functions-in-soplang]

Soplang waxa uu leeyahay hawlo muhiim ah oo si joogto ah u diyaar ah—daabacaad, akhris, beddel-nooc, leex-leexin tiro (rounding), abuuris liis/obj, iyo in ka badan—dhammaantood magacyo Soomaali ah.

📋 Built-in Function Reference [#-built-in-function-reference]

<Table>
  <TableHeader>
    <TableRow>
      <TableHead>
        Function
      </TableHead>

      <TableHead>
        Meaning
      </TableHead>

      <TableHead>
        English Equivalent
      </TableHead>

      <TableHead>
        Example
      </TableHead>
    </TableRow>
  </TableHeader>

  <TableBody>
    <TableRow>
      <TableCell className="font-mono text-primary">
        qor()
      </TableCell>

      <TableCell>
        Print to console
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        print()
      </TableCell>

      <TableCell className="font-mono text-xs">
        qor("Salaan, Adduunka!")
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        gelin()
      </TableCell>

      <TableCell>
        Read user input
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        input()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door magac = gelin("Magacaaga geli: ")
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        nooc()
      </TableCell>

      <TableCell>
        Get type of a value
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        typeof
      </TableCell>

      <TableCell className="font-mono text-xs">
        qor(nooc(magac))
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        abn()
      </TableCell>

      <TableCell>
        Convert to integer
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        int()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door n = abn("5")
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        jajab()
      </TableCell>

      <TableCell>
        Convert to float
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        float()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door f = jajab("3.14")
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        qoraal()
      </TableCell>

      <TableCell>
        Convert to string
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        str()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door s = qoraal(25)
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        bool()
      </TableCell>

      <TableCell>
        Convert to boolean
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        bool()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door b = bool(1)
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        teed()
      </TableCell>

      <TableCell>
        Create an array
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        list()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door liis = teed(1, 2, 3)
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        walax()
      </TableCell>

      <TableCell>
        Create an object
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        object()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door obj = walax(magac: "Ali")
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        daji()
      </TableCell>

      <TableCell>
        Round down
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        Math.floor()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door x = daji(4.9)
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        kor()
      </TableCell>

      <TableCell>
        Round up
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        Math.ceil()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door x = kor(4.2)
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        dherer()
      </TableCell>

      <TableCell>
        Length of string/list
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        len()/.length
      </TableCell>

      <TableCell className="font-mono text-xs">
        door l = "text".dherer()
      </TableCell>
    </TableRow>

    <TableRow>
      <TableCell className="font-mono text-primary">
        xul()
      </TableCell>

      <TableCell>
        Pick random number
      </TableCell>

      <TableCell className="font-mono text-muted-foreground">
        random()
      </TableCell>

      <TableCell className="font-mono text-xs">
        door n = xul(1, 6)
      </TableCell>
    </TableRow>
  </TableBody>
</Table>

🧪 Examples [#-examples]

**builtins\_examples.sop**

<SoplangCodeWindow
  title="builtins_examples.sop"
  code={`// Output
qor("Hello World")

// Input
door magac = gelin("Magacaaga geli: ")
qor("Magacaaga waa: " + magac)

// Type detection
door t = nooc(5)
qor("Type: " + t)

// Conversion
door a = abn("42")
door f = jajab("3.14")
door s = qoraal(100)
door b = bool(0)

// List and Object creation
door l = teed(1, 2, 3)
door o = walax(name: "Ayaan", age: 20)

// Math rounding
qor("Floor: " + daji(4.8))
qor("Ceil: " + kor(4.2))

// Random number
door r = xul(1, 6)
qor("Random: " + r)`}
/>

**Gunaanad:** built-ins-ka Soplang waxay ka dhigaan koodhka mid kooban, muujin leh, isla markaana si dabiici ah ugu qoran Af-Soomaali.


# Faq Quesions

   

General [#general]

What is Soplang? [#what-is-soplang]

Soplang is a programming language designed to be intuitive and powerful, with a focus on simplicity and readability. It allows you to write code in Somali.

Is it open source? [#is-it-open-source]

Yes, Soplang is open source and released under the MIT License.

Installation & Setup [#installation--setup]

How do I install Soplang? [#how-do-i-install-soplang]

You can install Soplang using npm or by downloading the binaries from our website.

Language Features [#language-features]

Does it support classes? [#does-it-support-classes]

Yes, Soplang supports object-oriented programming with classes and interfaces.

Community & Support [#community--support]

Where can I get help? [#where-can-i-get-help]

You can join our community discord or check the documentation for help.


# Introduction

   

Welcome to the Soplang documentation! Here you'll find everything you need to get started with Soplang, from installation to advanced features.

Getting Started [#getting-started]

* [Installation](/docs/00_installation) - Learn how to install Soplang
* [Getting Started](/docs/00_getting-started) - Write your first Soplang program

Language Basics [#language-basics]

* [Syntax Basics](/docs/01_syntax-basics) - Learn the fundamentals
* [Variables](/docs/03_variables) - Working with variables
* [Data Types](/docs/09_data-types) - Understanding data types
* [Operators](/docs/05_operators) - Using operators
* [Functions](/docs/08_functions) - Defining and using functions

Advanced Topics [#advanced-topics]

* [Arrays](/docs/12_arrays) - Working with arrays
* [Objects](/docs/13_objects) - Working with objects
* [Loops](/docs/07_loops) - Control flow with loops
* [Conditional Statements](/docs/06_conditional-statements) - Making decisions

Reference [#reference]

* [Keywords Reference](/docs/14_keywords-reference) - Complete keywords reference
* [Built-in Functions](/docs/15_built-in-functions) - Available built-in functions
* [FAQ](/docs/faq) - Frequently asked questions