Mash არის პროგრამირების ენა, რომელიც ადგენს თავის თავს

გილოცავთ ყველას ახალ 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 MyEnum [
  meFirst = "First",
  meSecond = 2,
  meThird
]
...
k ?= meSecond
...
if k in MyEnum:
  ...
end

ჩაშენებული ენა

პოტენციურად, Mash-ს შეუძლია იპოვოს თავისი ნიშა, როგორც ჩაშენებული პროგრამირების ენა, ლუას მსგავსი.

ამ მიზნებისთვის Mash-ის გამოყენების დასაწყებად, თქვენ არც კი გჭირდებათ პროექტის აწყობა თავად.

Mash-ს აქვს Runtime Environment - სტეკზე დაფუძნებული VM, რომელიც შედგენილია როგორც დინამიური ბიბლიოთეკა სრული API-ით.

ყველაფერი რაც თქვენ გჭირდებათ არის დაამატოთ ის პროექტის დამოკიდებულებაში და განახორციელოთ რამდენიმე ზარი.

თავად ენა უზრუნველყოფს ფუნქციონირებას ჩაშენებულ ენად მუშაობისთვის.
ამავდროულად, ენებთან და მესამე მხარის ბიბლიოთეკებთან ერთად შესრულება არ იმოქმედებს.
ჩვენ ვიღებთ ჩაშენებულ ენას, რომელსაც შეუძლია გამოიყენოს მასში დაწერილი სხვადასხვა ჩარჩოების სრული ძალა.

Mash + JVM

დავიწყე JVM-ისთვის მთარგმნელის ვერსიის შემუშავება.
შესაძლოა, N დროის შემდეგ, ამ თემაზე პოსტი გამოჩნდეს Habré-ზე.

შედეგები

კონკრეტული შედეგები არ არის. ეს არის შედეგების შუალედური წარმოდგენა.
წარმატებებს გისურვებთ ყველას 2020 წელს.

წყარო: www.habr.com