🥇Mash යනු තමන් විසින්ම සම්පාදනය කරන ක්‍රමලේඛන භාෂාවකි

2020 නව වසරේ සැමට සුබ පැතුම්.

පළමු පළකිරීමේ සිට තැපැල් මාෂ් ගැන හරියටම වසර 1 ක් පමණ ගත වී ඇත.

මෙම වසර තුළ, භාෂාව විශාල වශයෙන් වැඩිදියුණු කරන ලදී, එහි බොහෝ පැති ගැන සිතා බලා සංවර්ධනයේ දෛශිකය තීරණය කරන ලදී.

මේ සියල්ල සමාජය සමඟ බෙදා ගැනීමට ලැබීම ගැන මම සතුටු වෙමි.

වගකීමෙන් යුතුව ඔබ එවන

මෙම ව්‍යාපෘතිය තනිකරම උද්යෝගය මත සංවර්ධනය වෙමින් පවතින අතර ගතික ක්‍රමලේඛන භාෂා ක්ෂේත්‍රයේ ලෝක ආධිපත්‍යය මවාපාන්නේ නැත!

මෙම සංවර්ධනය උත්සාහ කළ යුතු ප්‍රමිතියක් ලෙස නොසැලකිය යුතුය; ව්‍යාපෘතිය පරමාදර්ශී නොවේ, නමුත් එය කෙසේ වෙතත් එය සංවර්ධනය වෙමින් පවතී.

GitHub
වෙබ් අඩවිය
සංසදය

නව සම්පාදකය

ව්‍යාපෘති ගබඩාවේ /mashc ශාඛාවේ, ඔබට සම්පාදකයේ නව අනුවාදයක් දැකිය හැකිය, එය Mash වලින් ලියා ඇත (භාෂාවේ පළමු අනුවාදය).

සම්පාදකයට asm ලැයිස්තුගත කිරීමේදී කේත උත්පාදක යන්ත්‍රයක් ඇත (ස්ටැක්-පාදක වීඑම් සඳහා එකලස් කරන්නා සඳහා).
දැනට මම 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

කාවැද්දූ භාෂාව

විභවයෙන්, Mash හට Lua ට සමාන කාවැද්දූ ක්‍රමලේඛන භාෂාවක් ලෙස එහි නිකේතනය සොයා ගත හැක.

මෙම අරමුණු සඳහා Mash භාවිතා කිරීම ආරම්භ කිරීම සඳහා, ඔබ විසින්ම ව්යාපෘතිය එකලස් කිරීමට පවා අවශ්ය නොවේ.

Mash සතුව Runtime Environment ඇත - සම්පූර්ණ API එකක් සහිත ගතික පුස්තකාලයක් ලෙස සම්පාදනය කරන ලද Stack-පාදක VM.

ඔබ කළ යුත්තේ එය ව්‍යාපෘති පරායත්තතාවයට එකතු කර ඇමතුම් කිහිපයක් ලබා දීමයි.

කාවැද්දූ භාෂාවක් ලෙස ක්‍රියා කිරීමට භාෂාවම ක්‍රියාකාරීත්වය සපයයි.
ඒ අතරම, භාෂාව සහ තෙවන පාර්ශවීය පුස්තකාල සමඟ ඒකාබද්ධව කාර්ය සාධනය බලපාන්නේ නැත.
එහි ලියා ඇති විවිධ රාමු වල සම්පූර්ණ බලය භාවිතා කළ හැකි embedded භාෂාවක් අපට ලැබේ.

Mash + JVM

මම JVM සඳහා පරිවර්තකයේ අනුවාදයක් සංවර්ධනය කිරීමට පටන් ගතිමි.
සමහර විට, N කාලයකට පසු, මෙම මාතෘකාව පිළිබඳ පළ කිරීමක් Habré හි දිස්වනු ඇත.

ප්රතිඵල

විශේෂිත ප්රතිඵල නොමැත. මෙය ප්රතිඵල අතරමැදි නිරූපණයකි.
2020 දී සැමට සුබ පැතුම්.

මූලාශ්රය: www.habr.com

Mash යනු තමන් විසින්ම සම්පාදනය කරන ක්‍රමලේඛන භාෂාවකි

වගකීමෙන් යුතුව ඔබ එවන