Lisette — Rust सिंटैक्स पर आधारित, Go runtime में compile होने वाली एक छोटी भाषा

 (lisette.run)
3 पॉइंट द्वारा GN⁺ 2026-04-07 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • Rust-स्टाइल सिंटैक्स का उपयोग करते हुए Go runtime पर चलने वाली एक छोटी भाषा, जो दोनों भाषाओं की खूबियों को जोड़ती है
  • algebraic data types, pattern matching, Hindley-Milner type system, default immutability आदि के जरिए सुरक्षा और अभिव्यक्तिशीलता को मजबूत करने वाली संरचना
  • Go packages का सीधा import, pipeline operator, try blocks, task-आधारित concurrency के माध्यम से Go ecosystem के साथ interoperability सुनिश्चित
  • compile-time error detection, स्पष्ट diagnostic messages, LSP support से developer experience और code stability में सुधार
  • Lisette code को पढ़ने में आसान Go code में बदला जाता है, जिससे मौजूदा Go projects के साथ स्वाभाविक रूप से integrate किया जा सकता है

Lisette अवलोकन

  • Lisette एक छोटी भाषा है जो Rust सिंटैक्स पर आधारित है और Go runtime में compile होती है
  • इसकी विशेषताओं में algebraic data types, pattern matching, nil का अभाव, Hindley-Milner type system, default immutability, और Go ecosystem के साथ interoperability शामिल हैं
  • इसे cargo install lisette कमांड से install किया जा सकता है, और Go के fmt, io, os जैसे packages को सीधे import करके इस्तेमाल किया जा सकता है

परिचित सिंटैक्स

  • इसमें Rust-जैसी सिंटैक्स संरचना है
    • enum और match के जरिए pattern matching का समर्थन
    • struct और impl blocks के जरिए methods define किए जा सकते हैं
  • यह एक expression-oriented language है, जिसमें if, let, blocks आदि सभी value return करते हैं
  • chaining और lambda का समर्थन होने से environment variables हैंडल करना या string manipulation संक्षेप में व्यक्त किया जा सकता है
  • interfaces और generics का समर्थन है, और interface definition तथा T: Trait constraints के साथ generic functions लिखी जा सकती हैं
  • if let और let else syntax से Option type को संक्षेप में handle किया जा सकता है

सुरक्षा

  • Go runtime में संभावित errors को compile time पर detect करना

    • match statement में यदि सभी patterns को handle नहीं किया गया हो तो error उत्पन्न होता है
    • nil का उपयोग संभव नहीं; missing values को Option<T> से दर्शाया जाता है
    • Result return value को ignore करने पर warning मिलती है
    • private type को public API में expose करने पर warning मिलती है
    • immutable variable को mutable argument के रूप में पास करने पर error होता है
    • struct field छूटने पर compile error होता है
    • diagnostic messages में सटीक code location और fix suggestions साथ में दिए जाते हैं
    • LSP(Language Server Protocol) support के कारण इसे VSCode, Neovim, Zed जैसे प्रमुख editors में इस्तेमाल किया जा सकता है

उपयोगिता

  • इसे Go के साथ interoperability पर खास ध्यान देकर डिजाइन किया गया है
  • pipeline operator(|>) से function chaining को संक्षेप में व्यक्त किया जा सकता है
  • try blocks के जरिए error propagation को सरल बनाया जा सकता है
  • concurrency को task और Channel के जरिए Go के goroutine की तरह लागू किया गया है
  • serialization attributes से JSON field names, omission, string conversion, validation tags आदि निर्धारित किए जा सकते हैं
  • panic recovery के लिए recover block दिया गया है, और Result type के जरिए सुरक्षित error handling संभव है
  • defer syntax का समर्थन है, जिससे resource cleanup या transaction rollback की गारंटी दी जा सकती है

पारदर्शी compile परिणाम

  • Lisette code को स्पष्ट और पढ़ने में आसान Go code में बदला जाता है
    • Option और Result types क्रमशः lisette.Option और lisette.Result structs में बदल जाते हैं
    • match syntax को Go के conditional statements में बदलकर हर branch को handle किया जाता है
    • ? operator को अंदरूनी तौर पर Result check code से प्रतिस्थापित किया जाता है
  • उदाहरण के तौर पर, classify function Option<int> लेता है और Go के explicit conditional statements में बदला जाता है, जबकि combine function Result की जांच करने वाले Go code में परिवर्तित होता है

अतिरिक्त जानकारी

  • आधिकारिक repository: github.com/ivov/lisette
  • यह MIT license के तहत जारी है, और 2026 के अनुसार Iván Ovejero द्वारा विकसित किया गया है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2026-04-07
Hacker News की राय

  • मैंने लेखक से बात की है और खुद भाषा को चलाकर नहीं देखा, लेकिन Lisette दिलचस्प लगती है और Go की तुलना में स्पष्ट रूप से बेहतर भाषा जैसी दिखती है
    फिर भी, मुझे लगता है कि Go की सीमाओं को पूरी तरह पार करना मुश्किल है। उदाहरण के लिए, Go के interface type से आने वाली typed nil समस्या को Lisette में Option से संभाला जाता है, लेकिन double unwrapping (Some(Some(h))) अटपटा लग सकता है
    इसके अलावा Go का defer तरीका अब भी असुविधाजनक है, और RAII की तरह अपने-आप resource release नहीं करता
    TypeScript ने JavaScript को इसलिए बेहतर बनाया क्योंकि browser में चलने वाला कोई विकल्प नहीं था, लेकिन अब WASM है, इसलिए स्थिति अलग है
    इसलिए मन में सवाल आता है, “जब Rust है तो Go को Rust जैसा क्यों बनाया जाए?”। हालांकि Lisette शायद इन दोनों के बीच की जगह को निशाना बना रही है
    आखिरकार, Lisette उन लोगों के लिए उपयुक्त भाषा लगती है जो मौजूदा Go codebase को बेहतर बनाना चाहते हैं या Go runtime का इस्तेमाल जारी रखना चाहते हैं
    मुझे जिस बात की कमी महसूस हुई, वह है quick start guide — “Go की जगह अगली file को Lisette में लिखना शुरू कैसे करूँ?”
    संबंधित ब्लॉग पोस्ट: Go is still not good

    • Go अब भी GC-आधारित concurrency runtime देने के मामले में अनोखी है
      जिन problem domain में complex reference graph को संभालना होता है, वहाँ GC ज़रूरी है, और Go की user-mode stack संरचना की वजह से इसका memory model काफ़ी efficient है
    • GC भाषा में development speed बहुत तेज़ होती है। मैंने Rust और Python में chatbot बनाया है, और Rust का अनुभव होने के बावजूद Python काफ़ी तेज़ निकली
      Go ऐसे तेज़ CLI tool बनाने के लिए भी उपयुक्त है — उदाहरण: wordle-tui
    • Go भाषा के रूप में कई मायनों में अजीब है, लेकिन compile target के रूप में शानदार है
      syntax सरल है, cross-platform support है, runtime और GC built-in हैं, “errors as values” संरचना है, green thread हैं, तेज़ AOT compiler है — ऐसे कई फायदे हैं
      Go का defer उपयोगी है, लेकिन error handling और scope rules अटपटे हैं
    • ब्लॉग में कही गई यह बात असरदार लगी कि “Go वह भाषा है जिसने गलती से NULL को दो बार बना दिया”
      TypeScript भी इस समस्या को हल नहीं कर सकी, बल्कि और खराब है। इसलिए मैंने खुद Option type package बनाकर NPM पर डाला → fp-sdk
    • Rust का async GC न होने की वजह से Go की तुलना में कम सुविधाजनक है। सिर्फ़ यही बात Go runtime चुनने की वजह बन सकती है

  • Go में compile होने वाली भाषाएँ पहले से कई हैं — XGo, Borgo, Soppo आदि

    • Borgo और Lisette (T, error) return को सिर्फ़ Result type से बदल देते हैं, लेकिन semantic रूप से यह पूरी तरह समान नहीं है
      उदाहरण के लिए io.Reader.Read में (n!=0, io.EOF) normal termination का मतलब होता है, इसलिए इसे सीधे error की तरह संभालना गलत behavior पैदा करेगा
    • यह जानने की जिज्ञासा है कि compile error target language से source language तक कैसे पहुँचते हैं

  • Lisette के error message की quality प्रभावशाली है। “help” hint सच में उपयोगी लगते हैं
    लेकिन Go में बदला गया code बहुत verbose हो सकता है, इसलिए runtime error आने पर Go code में debugging करनी पड़ेगी — यह चिंता की बात है
    साथ ही, मौजूदा Go code से Lisette को call करना मुश्किल दिखता है
    जिज्ञासा है कि Lisette एक experimental language है या सच में production को लक्ष्य बना रही है

    • डेवलपर ने खुद जवाब दिया: lis run --debug option इस्तेमाल करने पर Go code में //line source.lis:21:5 comment डाला जाता है, जिससे stack trace मूल Lisette code से map हो जाता है
      LSP compile-time error को .lis file के आधार पर संभालता है
      अभी Go से Lisette को call करने की सुविधा नहीं है, लेकिन Lisette से Go package import करने की सुविधा प्राथमिकता में है
      शुरुआत में यह एक experiment था, लेकिन इसे production-grade language बनाना लक्ष्य है

  • समझ नहीं आता कि Rust जैसी syntax को वैसे का वैसा क्यों नहीं लिया गया
    उदाहरण: import "foo.bar" की जगह use foo::bar, Bar.Baz => की जगह Bar::Baz => आदि
    जो लोग Rust जानते हैं वे भ्रमित होंगे, और जो नहीं जानते वे Rust की जानकारी यहाँ से transfer नहीं कर पाएँगे

    • ऐसी syntax का अंतर मामूली है; असली बात Rust के type system को Go में लाना है
      int और float64 जैसे नाम Go की type naming convention का पालन करते हैं
    • कई भाषाओं के बीच आते-जाते रहने पर syntax की समानता उल्टा भ्रम पैदा करती है। जैसे PHP में + की जगह . लिखना होता है, यह मैं अक्सर भूल जाता हूँ
    • मैंने भी पहले TypeScript-आधारित Rust-style language बनाने की सोची थी, लेकिन आखिर में समझ आया कि Rust खुद उतनी कठिन नहीं है जितनी लगती है
    • GC भाषा में Rust-style memory model लागू करना बहुत अप्राकृतिक है। मानो हर object का अपना अलग address space हो, इसलिए जटिलता बढ़ती है
    • Lisette, Rust से प्रेरित भाषा है; वह Rust बनना नहीं चाहती। इसका मुख्य target Go developer हैं

  • Go runtime अच्छा है, लेकिन भाषा खुद भारी-भरकम और सुधार की इच्छा से रहित लगती है
    इसलिए अगर कोई transpiler तक इस्तेमाल कर रहा है, तो शायद उसे सच में Go से नफ़रत होगी

  • समझ नहीं आता कि Rust और Rust-जैसी भाषाएँ struct और method को अलग क्यों रखती हैं
    struct के अंदर method सीधे define क्यों नहीं किए जा सकते, यह सवाल है

    • Rust में struct field, auto-trait को प्रभावित करते हैं, इसलिए fields को एक नज़र में देख पाना महत्वपूर्ण है
      साथ ही impl block पर struct से अलग generic constraints लगाए जा सकते हैं, इसलिए कई impl define किए जा सकते हैं
      और अंत में, Rust ऐसी भाषा है जिसे डेटा की shape को केंद्र में रखकर सोचने के लिए डिज़ाइन किया गया है
    • व्यक्तिगत रूप से, मुझे impl block Go के method जैसे लगते हैं; कौन-सा बेहतर है, यह कहना मुश्किल है

  • अगर Python जैसा दिखने वाली कोई भाषा हो जो Rust या Go में compile हो जाए, तो वह सच में शानदार होगी

    • Mojo, Swift के निर्माता की बनाई हुई Python syntax-आधारित high-performance language है
    • Spy C में compile होने की शुरुआती कोशिश है, और Nim भी इसी तरह की एक अधिक परिपक्व भाषा है
    • Nim में Python जैसी syntax है, static type system है, और यह wasm, C आदि कई target पर compile होती है
    • Static Python Skill Python को statically compile करने की एक कोशिश है
    • Grumpy, Google का Python→Go transpiler था, लेकिन 9 साल से update नहीं हुआ (Python 2.7 के लिए)

  • Lisette, Go की सादगी और Rust की जटिलता के बीच अच्छा संतुलन बनाने वाली भाषा लगती है
    क्या वजह है कि इसकी compile speed Go से बहुत धीमी हो, और Rust की कौन-सी सुविधाएँ जानबूझकर छोड़ी गई हैं — यह जानना दिलचस्प होगा
    उदाहरण: borrow checking, data type, async आदि

  • Go सीखना आसान है, लेकिन features कम हैं
    Lisette वह भाषा लगती है जो इस खाली जगह को भरती है, इसलिए दिलचस्प है
    जैसे TypeScript ने JavaScript को बढ़ाया, वैसे ही अगर Go में expressive type system और strict compiler जोड़ दिए जाएँ, तो वह एक शानदार backend language बन सकती है
    मेरी व्यक्तिगत सलाह होगी कि TypeScript frontend के साथ type sharing का support दिया जाए। backend में TypeScript के लोकप्रिय होने की यह भी एक बड़ी वजह है

  • एक infrastructure automation developer के रूप में, जो Rust की safety और Go की simplicity के बीच सोचता रहता है, Go runtime पर Rust की usability चढ़ाने का विचार बहुत आकर्षक लगता है
    मैं इस project की प्रगति पर नज़र बनाए रखूँगा