# SLJ
Programski jezik v slovenščini | A programming language in Slovenian

SLJ je enostaven interpretiran programski jezik v slovenščini. Nastal je kot nadgradnja enostavnega kalkulatorja, razvil pa se je v nekaj precej zmogljivejšega.

Spodaj je primer uporabe jezika, v katerem je prisotna večina konstruktov jezika.

	funkcija je_deljivo(deljenec: celo, delitelj: celo) -> bool {
	    vrni deljenec % delitelj == 0
	}

	funkcija je_praštevilo(kandidat: celo, praštevila: @[celo]) -> bool {
	    za i = 0, praštevila[i]**2 < kandidat, i += 1 {
		če je_deljivo(kandidat, praštevila[i]) {
		    vrni laž
		}
	    }
	    vrni resnica
	}

	funkcija poišči_praštevila(od: celo, do: celo, praštevila: @[celo], praštevil: @celo) {
	    za kandidat = od, kandidat <= do, kandidat += 2 {
		če je_praštevilo(kandidat, praštevila) {
		    praštevila[praštevil@] = kandidat
		    praštevil@ += 1
		}
	    }
	}

	naj praštevila: [celo; 200]
	praštevila[0] = 2
	praštevila[1] = 3
	naj praštevil = 2


	poišči_praštevila(5, praštevila.dolžina, @praštevila, @praštevil)

	za i = 0, i < praštevil, i += 1 {
	    natisni!(praštevila[i], " ")
	}

	natisni!("\npraštevil do ", praštevila.dolžina, ": ", praštevil, "\n")

# Konstrukti
## Spremenljivke in prirejanje
	naj x = 1
	x = x + 3.0 # Napaka E5: Nemogoča operacija: celo + real (2, 7)
	x = x + 3

## Osnovni tipi
	naj odgovor: celo # cela števila
	naj pi: real      # realna števila
	naj enako: bool   # boolove vrednosti
	naj č: znak
	odgovor = 3.14 # Napaka E3: Nemogoča operacija: celo = real (4, 1)
	odgovor = 42
	pi = 3.14
	enako = laž
	č = 'č'

## Reference
	naj a = 13
	naj ra = @a
	natisni(a)
	natisni(ra)  # Napaka E2: Funkcija 'natisni(@celo)' ne obstaja (5, 1)
	
	# dereferenciranje
	ra@ = 7
	natisni(ra@) # 7
	
## Seznami
	naj seznam: [real; 64]
	seznam[0] = 1 # Napaka E3: Nemogoča operacija: real = celo (2, 1)
	seznam[0] = 1.0
	seznam[1] = 2.0
	seznam[2] = 3.0

## Reference na sezname
Reference na sezname so enake za sezname vseh dolžin; seznama `[real; 13]` in `[real; 42]`  imata različna tipa, a imata oba referenco tipa `@[real]`.
Tako lahko implementiramo eno funkcijo za sezname vseh dolžin.

	funkcija vsebuje(seznam: @[real], št: real) -> bool {
	    za i = 0, i < seznam.dolžina, i += 1 {
	        če seznam[i] == št {
	            vrni resnica
	        }
	    }
	    vrni laž
	}
	
	naj a: [real; 13]
	naj b: [real; 42]
	naj c: [celo; 15]

	vsebuje(@a, 4.0)
	vsebuje(@b, 0.0)
	vsebuje(@c, -1) # Napaka E2: Funkcija 'vsebuje(@[celo], celo)' ne obstaja (16, 1)

## Operacije
	# aritmetične in bitne operacije
	naj x = 16 - 3
	x = x + 2
	x += 1
	x = 2**3
	x = 1 << 3
	x = x % 5
	x >>= 1 | 3
	
	# Boolove operacije
	naj b = laž
	b = !laž
	b = b && laž
	b ||= resnica
	b  ^= laž
	
	# pretvorbe med tipi
	naj a = 13.0
	a += 29 kot real
	naj nič = 48 kot znak
	nič += 11 kot znak # Napaka E3: Nemogoča operacija: znak += znak (4, 5)
	nič = (nič kot celo + 11) kot znak

	# primerjalne operacije
	naj enako = 13 == 11 + 2.0 # Napaka E5: Nemogoča operacija: celo + real (1, 22)
	naj večje = 13 > 14
	naj me    = 14 <= 14
	# ...
	
## Zanke
Zanka `dokler`:
	
	dokler seznam[0] {
	}
	# Napaka E6: Pogoj mora biti Boolova vrednost (1, 8)

	naj i = 0
	dokler seznam[i] > 0 {
		...
		i += 1
	}

Zanka `za`:

	za i = 0, i < seznam.dolžina, i += 1 {
		...
	}

## Pogojni stavki
	če št > 9 {
		...
	}
	čene če št > 0 {
		...
	}
	čene {
		...
	}

## Funkcije
	funkcija je_deljivo(deljenec: celo, delitelj: celo) {
	    vrni deljenec % delitelj == 0
	}
	# Napaka E3: Ne morem vrniti spremenljivke tipa 'bool' iz funkcije tipa 'brez' (2, 10)
	
	funkcija je_praštevilo(kandidat: celo, praštevila: @[celo]) -> bool {
	    za i = 0, praštevila[i]**2 < kandidat, i += 1 {
	        če je_deljivo(kandidat, i) {
	            vrni laž
	        }
	    }
	    vrni resnica
	}

## Multifunkcijski klic
Če obstaja več funkcij z enakim imenom, ki sprejemajo vsaka po en argument, lahko uporabimo multifunkcijski klic. Izgleda podobno kot navaden klic funkcije, le da za ime njeno dodamo `!`. Najboljši primer uporabe multifunkcijskih klicev je tiskanje.

	funkcija natisni(niz: @[znak]) {
	    naj dolžina = niz.dolžina
	    za i = 0, i < dolžina, i += 1 {
	        natisni(niz[i])
	    }
	}

	funkcija natisni(št: celo) {
	    če št > 9 {
	        natisni(št / 10)
	    }
	    # natisni(znak) je vprajena funkcija
	    natisni((št % 10 + '0' kot celo) kot znak)
	}

	natisni!("7! = ", faktoriela(7), "\n")