Rashi Plus Plus - the new Hebrew scripting language
Switch branches/tags
Nothing to show
Clone or download
daniel-shimon more io fixes
toString outputs hebrew names for bool, object etc
better builtins syntax
Latest commit b1f9865 Oct 29, 2018
Permalink
Failed to load latest commit information.
examples primes example fix Mar 14, 2018
src more io fixes Oct 28, 2018
.gitignore io with hebrew! Oct 26, 2018
CMakeLists.txt io with hebrew! Oct 26, 2018
LICENSE Initial commit Jan 28, 2018
README.md io with hebrew! Oct 26, 2018

README.md

RPP

Rashi Plus Plus - the new Hebrew scripting language

Interpreted, untyped, object-oriented and super cool.

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

Table of Contents

Installation

Windows

A precompiled version for Win32 is available in the release section

 g++ -std=c++11 -static src/*.h src/*.cpp -o rpp.exe

Linux

As simple as they get 😄

g++ -std=c++11 src/*.h src/*.cpp -o rpp

Variables, comparison and math

מ = 10
מ = מ / 100
פלוט מ // 0.1
מ = ((מ ** 2) * 300) % 40
פלוט מ // 3
פלוט מ שווהל 100 או 1 == 1 // true
פלוט מ גדולמ 70 וגם שקר // false
פלוט לא (מ קטןמ 0.34) // true

Operators

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 לא

Control flow

מ = 1

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

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

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

// 0, 1, 2, ...

Keywords

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

Flexible syntax

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

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, ...

Classes

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

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

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

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

Magic methods (dunders)

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

Exceptions are thrown and caught by class type

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

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

נסה:
    זורק()
תפוס רשימה בתור א:
    פלוט א

Exception types

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

Built-ins

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

List

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

Dictionary

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

For looping a Dictionary will yield it's keys

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

Range

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 פלוט "זוגי" אחרת פלוט "איזוגי"
// זוגי, איזוגי, ...

I/O

  • Printing to console: the פלוט command.
  • Receiving input from the user: the (פלט)קלוט function

Currently, rpp translates hebrew output to english letters to cope with rtl and hebrew in the windows console 😓

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

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

Range

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 פלוט "זוגי" אחרת פלוט "איזוגי"
// זוגי, איזוגי, ...

Random

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)

Conversions and types

  • String literals can be written with single (') or double (") quotes
פלוט "המספר הוא " + טקסט(34) // המספר הוא 34
פלוט מספר("3") * 2 // 6
פלוט סוג(אמת) // 

Patterns

The Iterator pattern

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
		
        אם אני.א שווהל אני.רשימה_א.גודל():
            זרוק __שגיאת_עצירה__()
        החזר אני.רשימה_א[אני.א] + ' ' + אני.רשימה_ב[אני.ב]

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

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