મેશ એક પ્રોગ્રામિંગ લેંગ્વેજ છે જે પોતે કમ્પાઈલ કરે છે.

નવા વર્ષ 2020 ની સૌને શુભેચ્છાઓ.

પ્રથમ ના પ્રકાશન થી પોસ્ટ મેશને લગભગ બરાબર 1 વર્ષ વીતી ગયું છે.

આ વર્ષ દરમિયાન, ભાષામાં ઘણો સુધારો કરવામાં આવ્યો છે, તેના ઘણા પાસાઓ પર વિચાર કરવામાં આવ્યો છે અને વિકાસ વેક્ટર નક્કી કરવામાં આવ્યો છે.

જે તમામ સમુદાય સાથે શેર કરવામાં મને આનંદ થાય છે.

જવાબદારીનો ઇનકાર

આ પ્રોજેક્ટ ફક્ત ઉત્સાહ પર વિકસાવવામાં આવી રહ્યો છે અને ગતિશીલ પ્રોગ્રામિંગ ભાષાઓના ક્ષેત્રમાં વિશ્વના વર્ચસ્વનો ડોળ કરતો નથી!

તમારે આ વિકાસને એક ધોરણ તરીકે ધ્યાનમાં લેવું જોઈએ નહીં કે જેના માટે તમારે પ્રયત્ન કરવાની જરૂર છે, પ્રોજેક્ટ આદર્શ નથી, પરંતુ તેમ છતાં તે વિકાસ પામે છે.

GitHub
વેબસાઇટ
ફોરમ

નવું કમ્પાઈલર

પ્રોજેક્ટ રીપોઝીટરીની /mashc શાખામાં, તમે કમ્પાઈલરનું નવું સંસ્કરણ જોઈ શકો છો, જે Mash (ભાષાનું પ્રથમ સંસ્કરણ) માં લખેલું છે.

કમ્પાઇલર પાસે asm સૂચિમાં કોડ જનરેટર છે (સ્ટેક VM હેઠળ એસેમ્બલર માટે).
આ ક્ષણે હું Java (JDK 1.8) માટે જનરેટરનું સંસ્કરણ વિકસાવી રહ્યો છું.

કમ્પાઇલરનું નવું સંસ્કરણ ભાષાના પ્રથમ સંસ્કરણની કાર્યક્ષમતાને સંપૂર્ણપણે સમર્થન આપે છે અને તેને પૂરક બનાવે છે.

નવું OOP

ભાષાના નવા સંસ્કરણમાં, વર્ગો સાથેના કાર્યને કંઈક અંશે ફરીથી ડિઝાઇન કરવામાં આવ્યું છે.
વર્ગ પદ્ધતિઓ વર્ગના મુખ્ય ભાગમાં અને તેની બહાર બંને રીતે જાહેર કરી શકાય છે.
વર્ગમાં હવે સ્પષ્ટ કન્સ્ટ્રક્ટર છે: init.

કોડ ઉદાહરણ:

...
class MyClass:
  private:
    var a, b

  public:
    init(a, b):
      $a ?= a
      $b ?= b
    end

    func Foo():
      return $a + $b   
    end
end

func MyClass::Bar(c):
  return $a + $b + c
end
...

જો વારસો મળે, તો અમારી પાસે વારસાગત કૉલ્સ (સુપર) સરળતાથી કરવાની ક્ષમતા છે.

કોડ ઉદાહરણ:

...
class MySecondClass(MyClass):
  public:
    var c

    init(a, b, c):
      super(a, b)
      $c ?= c
    end

    func Bar():
      super($c)  
    end
end
...

x ?= new MySecondClass(10, 20, 30)
println( x -> Bar() )     // 60

વર્ગના દાખલાઓ માટે પદ્ધતિઓનું ગતિશીલ ઓવરરાઇડિંગ:

...
func Polymorph::NewFoo(c):
  return $a + $b + c  
end
...
x -> Foo ?= Polymorph -> NewFoo
x -> Foo(30)    // 60

પેકેજો / નેમસ્પેસ

નેમસ્પેસ સ્વચ્છ રહેવી જોઈએ!
તદનુસાર, ભાષાએ આ તક પૂરી પાડવી જોઈએ.
Mash માં, જો વર્ગ પદ્ધતિ સ્થિર હોય, તો તેને કોડના કોઈપણ ભાગમાંથી સુરક્ષિત રીતે કૉલ કરી શકાય છે.

ઉદાહરણ:

...
class MyPackage:
  func MyFunc(a, b):
    return a + b  
  end
end
...
println( MyPackage -> MyFunc(10, 20) )    // 30

માર્ગ દ્વારા, સુપર ઓપરેટર આવા કૉલ સાથે યોગ્ય રીતે કાર્ય કરશે.

અપવાદો

ભાષાના નવા સંસ્કરણમાં, તેઓને વર્ગોની જેમ ગણવામાં આવે છે:

...
try:
  raise new Exception(
    "My raised exception!"
  )
catch E:
  if E is Exception:
    println(E)
  else:
    println("Unknown exception class!")
  end
end
...

નવું enum

હવે ગણતરીના ઘટકોને સતત મૂલ્યો અસાઇન કરી શકાય છે:

enum MyEnum [
  meFirst = "First",
  meSecond = 2,
  meThird
]
...
k ?= meSecond
...
if k in MyEnum:
  ...
end

એમ્બેડેડ PL

સંભવિત રીતે - મેશ લુઆની જેમ એમ્બેડ કરી શકાય તેવી પ્રોગ્રામિંગ ભાષા તરીકે તેનું વિશિષ્ટ સ્થાન શોધી શકે છે.

આ હેતુઓ માટે મેશનો ઉપયોગ શરૂ કરવા માટે, તમારે પ્રોજેક્ટ જાતે બનાવવાની પણ જરૂર નથી.

Mash પાસે રનટાઇમ એન્વાયર્નમેન્ટ છે - સંપૂર્ણ API સાથે ડાયનેમિક લાઇબ્રેરી તરીકે બનેલ સ્ટેક VM.

તમારે ફક્ત તેને પ્રોજેક્ટ નિર્ભરતામાં ઉમેરવાની અને થોડા કૉલ્સ કરવાની જરૂર છે.

ભાષા પોતે જ એમ્બેડેડ ભાષા તરીકે કાર્ય કરવા માટે કાર્યક્ષમતા પ્રદાન કરે છે.
તે જ સમયે, ભાષા અને તૃતીય-પક્ષ પુસ્તકાલયો સાથે જોડાણમાં કામગીરીનું ઉલ્લંઘન થતું નથી.
અમને એમ્બેડેબલ ભાષા મળે છે જે તેમાં લખેલા વિવિધ ફ્રેમવર્કની સંપૂર્ણ શક્તિનો ઉપયોગ કરી શકે છે.

મેશ + JVM

JVM માટે અનુવાદકનું સંસ્કરણ વિકસાવવાનું શરૂ કર્યું.
કદાચ, N-th સમય પછી, આ વિષય પરની પોસ્ટ Habré પર દેખાશે.

પરિણામો

ત્યાં કોઈ ચોક્કસ પરિણામો નથી. આ પરિણામોની મધ્યવર્તી રજૂઆત છે.
2020 માં દરેકને શુભકામનાઓ.

સોર્સ: www.habr.com