Skip to content

Rashi Plus Plus - the new Hebrew scripting language

License

Notifications You must be signed in to change notification settings

daniel-shimon/rpp

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

65 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Rashi Plus Plus (RPP) - The New Hebrew Scripting Language

Release version Code size Stars Build status License

Interpreted, untyped, object-oriented and super cool.

פלוט 'שלום עולם!'

Table of Contents

The project depends on cmake and gcc (MinGW64 on windows).

A precompiled version for Windows x64 is available in the release section.
mkdir build
cd build
cmake ..
make
מ = 10
מ = מ / 100
פלוט מ // 0.1
מ = ((מ ** 2) * 300) % 40
פלוט מ // 3
פלוט מ שווהל 100 או 1 == 1 // true
פלוט מ גדולמ 70 וגם שקר // false
פלוט לא (מ קטןמ 0.34) // true

Any of the c-style operators can be used interchangeably with the hebrew keywords

c-style rpp
== שווהל
!= שונהמ
> גדולמ
< קטןמ
>= ---
<= ---
! לא
/ חלקי
* כפול
% ---
- ---
+ ---
  • Power operator: ** (python-style)
  • Boolean values: אמת and שקר
  • Boolean operators: או, וגם and לא
מ = 1

כלעוד מ קטןמ 10:
	אם מ שווהל 2:
		פלוט 'שתיים'
	אחרת אם מ % 2 == 0:
		פלוט 'זוגי'
	אחרת:
		פלוט 'אי-זוגי'
	מ = מ + 1

// אי-זוגי
// שתיים
// אי-זוגי
// זוגי
// ...

לכל מ בתוך טווח(100):
	פלוט מ

// 0, 1, 2, ...
c-style rpp
if אם
else אחרת
while כלעוד
continue המשך
break שבור
python-style rpp
for לכל
in בתוך

All code blocks can be written in a one-line form or a multi-line indented block

כלעוד אמת:
    פלוט 1

כלעוד אמת פלוט 1

אם שקר פלוט 1 אחרת אם אמת פלוט 2 אחרת:
    פלוט 3
// 2

Supported code blocks:

  • if, else if, else
  • functions
  • classes
  • while loops
  • for loops
  • try, catch

Functions in rpp are declared similarly to JavaScript - they can be declared by name or anonymously

פיב = פעולה(מ):
	אם מ == 0 או מ == 1:
		החזר 1
	החזר פיב(מ - 1) + פיב(מ - 2)

פלוט_פיב = פעולה(מ) פלוט פיב(מ)

לכל מ בתוך טווח(5):
	פלוט_פיב(מ)

// 1, 1, 2, 3, 5, ...

Class declarations are declared similarly to functions (named or anonymous)

מחלקה חישובים:
    פעולה כפל(א, ב):
        החזר א * ב

פלוט חישובים.כפל(4, 2)
// 8

חישובים2 = מחלקה:
    פעולה ריבוע(מ):
        החזר מ ** 2
        
פלוט חישובים2.ריבוע(3)
// 9

Similarly to Python, rpp classes can implement "magic" methods that run in certain situations

מחלקה סניף:
    פעולה __אתחל__(שם):
        אני.שם = שם
        אני.עובדים = רשימה()
    
    פעולה הוסף_עובד(שם_עובד):
        אני.עובדים.הוסף(שם_עובד)
    
    פעולה הסר_עובד_אחרון():
        אני.עובדים.הסר(אני.עובדים.גודל() - 1)
    
    פעולה __טקסט__():
        החזר אני.שם + ': ' + טקסט(אני.עובדים)

סניף_מרכזי = סניף('תל אביב')
סניף_מרכזי.הוסף_עובד('דניאל')

פלוט סניף_מרכזי

// תל אביב: [דניאל]
python-style rpp
__init__ __אתחל__
__str__ __טקסט__
__getitem__ __קח__
__setitem__ __שים__
__next__ __הבא__
__iterator__ __איטרטור__

Exceptions are thrown and caught by class type

python-style rpp
try נסה
catch תפוס
as בתור
throw זרוק
נסה:
    ר = רשימה(1, 2)
    ר[23]
תפוס __שגיאת_מיקום__:
    פלוט 'שיט'

פעולה זורק():
    ערך = רשימה(1, 2)
    זרוק ערך

נסה:
    זורק()
תפוס רשימה בתור א:
    פלוט א
  • Index exception (thrown in list): __שגיאת_מיקום__
  • Key exception (thrown in dictionary): __שגיאת_מפתח__
  • Stop exception (thrown in iterator end): __שגיאת_עצירה__

As all great programming languages, rpp is equipped with some useful built-ins

ר = רשימה(1,2,3)
ר[2] = אמת
פלוט ר.גודל() // 3
ר.הוסף('שלום')
ר.הוצא(0)
פלוט ר.מצא(אמת) // 2
פלוט ר.מצא('היי') // -1
פלוט ר // [אמת, 3, 'שלום']
לכל איבר בתוך ר:
    פלוט איבר

Dictionaries in rpp support only string keys and any type of values

For looping a Dictionary will yield it's keys

ר = מילון()
ר['שם'] = 'רשי ועוד ועוד'
ר['גרסה'] = '0.1'
פלוט ר.גודל() // 2
ר.הוצא('גרסה')
פלוט ר.מכיל('שם') // אמת
פלוט ר // {'שם': 'רשי ועוד ועוד'}
לכל מפתח בתוך ר:
    פלוט מפתח
// שם

Similarly to Python, rpp has a built-in Range functionality, with two calling signatures:

  • Iterate from 0 to max-1: טווח(12)
  • Iterate from min to max-1: טווח(10, 20)
לכל מ בתוך טווח(10) אם מ % 2 שווהל 0 פלוט "זוגי" אחרת פלוט "איזוגי"
// זוגי, איזוגי, ...
  • Printing to console: the פלוט command.
  • Receiving input from the user: the (פלט)קלוט function

Currently, Rashi Plus Plus supports hebrew I/O in the console!

Hebrew Console I/O

(To enable hebrew in the windows console, please enable a TrueType font such as "Courier New")

פלוט 'שלום'
פלוט 90
פלוט אמת
פלוט רשימה()

קלוט('>')
קלוט('מי אתה? ')
קלוט()

Similarly to Python, rpp has a built-in Range functionality, with two calling signatures:

  1. Iterate [0, max): טווח(12)
  2. Iterate [min, max): טווח(10, 20)
לכל מ בתוך טווח(10) אם מ % 2 שווהל 0 פלוט "זוגי" אחרת פלוט "איזוגי"
// זוגי, איזוגי, ...

Three random function signatures:

  1. Random real number in range [0, 1): ()אקראי
  2. Random integer in range [0, max): אקראי(3)
  3. Random integer in range [min, max): אקראי(1000, 2000)
  • String literals can be written with single (') or double (") quotes
פלוט "המספר הוא " + טקסט(34) // המספר הוא 34
פלוט מספר("3") * 2 // 6
פלוט סוג(אמת) // 

To implement an Iterator in rpp, a class must implement the following:

  • Return the iterator: __איטרטור__()
  • Return the next value and throw __שגיאת_עצירה__ on end: __הבא__()
מחלקה קומבינציות:
    פעולה __אתחל__(רשימה_א, רשימה_ב):
        אני.רשימה_א = רשימה_א
        אני.רשימה_ב = רשימה_ב
    פעולה __איטרטור__():
        אני.א = 0
        אני.ב = -1
        החזר אני
    פעולה __הבא__():
		אני.ב = אני.ב + 1
        
		אם אני.ב שווהל אני.רשימה_ב.גודל():
            אני.ב = 0
            אני.א = אני.א + 1
		
        אם אני.א שווהל אני.רשימה_א.גודל():
            זרוק __שגיאת_עצירה__()
        החזר אני.רשימה_א[אני.א] + ' ' + אני.רשימה_ב[אני.ב]

שמות = קומבינציות(רשימה('דניאל', 'דני', 'רון'), רשימה('שמעון', 'בכר'))

לכל שם בתוך שמות:
    פלוט שם