మాష్ అనేది స్వయంగా కంపైల్ చేసుకునే ప్రోగ్రామింగ్ లాంగ్వేజ్

2020 కొత్త సంవత్సరంలో అందరికీ శుభాకాంక్షలు.

మొదటి ప్రచురణ నుండి పోస్ట్ మాష్ గురించి దాదాపు సరిగ్గా 1 సంవత్సరం గడిచింది.

ఈ సంవత్సరంలో, భాష చాలా మెరుగుపడింది, దానిలోని అనేక అంశాలు ఆలోచించబడ్డాయి మరియు అభివృద్ధి యొక్క వెక్టర్ నిర్ణయించబడింది.

ఇవన్నీ సమాజంతో పంచుకోవడం నాకు సంతోషంగా ఉంది.

నిరాకరణ

ఈ ప్రాజెక్ట్ కేవలం ఉత్సాహంతో అభివృద్ధి చేయబడుతోంది మరియు డైనమిక్ ప్రోగ్రామింగ్ భాషల రంగంలో ప్రపంచ ఆధిపత్యం ఉన్నట్లు నటించదు!

ఈ అభివృద్ధిని ప్రయత్నించవలసిన ప్రమాణంగా పరిగణించకూడదు; ప్రాజెక్ట్ ఆదర్శవంతమైనది కాదు, అయితే ఇది అభివృద్ధి చెందుతోంది.

గ్యాలరీలు
వెబ్సైట్
ఫోరమ్

కొత్త కంపైలర్

ప్రాజెక్ట్ రిపోజిటరీ యొక్క /mashc బ్రాంచ్‌లో, మీరు కంపైలర్ యొక్క కొత్త వెర్షన్‌ను చూడవచ్చు, ఇది మాష్‌లో వ్రాయబడింది (భాష యొక్క మొదటి వెర్షన్).

కంపైలర్ asm లిస్టింగ్‌లో కోడ్ జెనరేటర్‌ను కలిగి ఉంది (స్టాక్-ఆధారిత VM కోసం అసెంబ్లర్ కోసం).
ప్రస్తుతం నేను జావా (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

ప్యాకేజీలు/నేమ్‌స్పేస్‌లు

నేమ్‌స్పేస్ శుభ్రంగా ఉండాలి!
దీని ప్రకారం, భాష ఈ అవకాశాన్ని అందించాలి.
మాష్‌లో, తరగతి పద్ధతి స్థిరంగా ఉంటే, అది కోడ్‌లోని ఏదైనా భాగం నుండి సురక్షితంగా కాల్ చేయవచ్చు.

ఉదాహరణకు:

...
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 MyEnum [
  meFirst = "First",
  meSecond = 2,
  meThird
]
...
k ?= meSecond
...
if k in MyEnum:
  ...
end

పొందుపరిచిన భాష

సంభావ్యంగా, మాష్ లువా మాదిరిగానే ఎంబెడెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్‌గా దాని సముచిత స్థానాన్ని కనుగొనవచ్చు.

ఈ ప్రయోజనాల కోసం మాష్‌ను ఉపయోగించడం ప్రారంభించడానికి, మీరు ప్రాజెక్ట్‌ను మీరే సమీకరించాల్సిన అవసరం లేదు.

మాష్ రన్‌టైమ్ ఎన్విరాన్‌మెంట్‌ను కలిగి ఉంది - పూర్తి APIతో డైనమిక్ లైబ్రరీగా కంపైల్ చేయబడిన స్టాక్-ఆధారిత VM.

మీరు చేయాల్సిందల్లా ప్రాజెక్ట్ డిపెండెన్సీకి జోడించి, రెండు కాల్స్ చేయండి.

ఎంబెడెడ్ లాంగ్వేజ్‌గా పని చేయడానికి భాష స్వయంగా కార్యాచరణను అందిస్తుంది.
అదే సమయంలో, భాష మరియు థర్డ్-పార్టీ లైబ్రరీలతో కలిపి పనితీరు ప్రభావితం కాదు.
అందులో వ్రాయబడిన వివిధ ఫ్రేమ్‌వర్క్‌ల యొక్క పూర్తి శక్తిని ఉపయోగించగల ఎంబెడెడ్ భాషని మేము పొందుతాము.

మాష్ + JVM

నేను JVM కోసం అనువాదకుని సంస్కరణను అభివృద్ధి చేయడం ప్రారంభించాను.
బహుశా, N సమయం తర్వాత, ఈ అంశంపై పోస్ట్ Habréలో కనిపిస్తుంది.

ఫలితాలు

ప్రత్యేక ఫలితాలు లేవు. ఇది ఫలితాల ఇంటర్మీడియట్ ప్రాతినిధ్యం.
2020లో అందరికీ శుభాకాంక్షలు.

మూలం: www.habr.com