Arc-Script feature ideas

[segeljakt]

When designing Arc-Script, languages which could be good to borrow ideas from are:

• Go (For its simplicity and concurrency-oriented design)
• Julia (For its data-science oriented design)
• Rust (For its safety, performance, and sane design)
• Scala (For its scalability and functional syntax)
• Python (For its conciseness)
• OCaml (For its conciseness without compromising static typing)
• Javascript (For its simplicity)
• Erlang (For its simplicity and concurrency-oriented design)
• Pony (For its actor model and static typing)
• Swift (For its simplicity and IR)
• Zig (For performance, safety)

One thing to be noted is that Arc-Script is a statically typed compiled language. Of the above languages, only Rust shares the same design principle. Therefore it is necessary to include Rust in the discussion.

Following is a list of features which are either up for discussion💡, rejected ❌, accepted 👍 (but not decided how it should be implemented), or implemented ✅.

• ✅ Static typing (Rust, OCaml, Scala)
• ✅ Sum-types (Rust, OCaml)
• ✅ Record-types (OCaml)
• 💡 Public/Private visibility
• 💡 Semantic indentation (Python)
• 💡 begin and end syntax (Julia)
• 💡 Sequential composition at line break (Python)
• 💡 Functions with multiple results (Python/Go)
• 💡 Named return values (Go)
• 💡 Zero-values for all basic types (Go)
• 💡 Explicit conversions (Go/Rust)
• 💡 Methods are functions with receivers (Go)
• 💡 Interfaces (Go)
• 💡 Implicit implementations (Go)
• 💡 Consecutive parameters with same type (Go)
• 💡 Defer statements (Go)
• 💡 Static/Dynamic Arrays and Slices (Go/Rust)
• 💡 Channels (Go)
  • 💡 Channels can be opened and closed
  • 💡 Channels can have directions, i.e., capabilities
  • 💡 Selective receive
  • 💡 Non-blocking default case in receive
• 💡 Builtin map type (Go)
• 💡 Builtin string type (Go)
• 💡 Builtin rune type (Go)
• 💡 Builtin imaginary type (Go)
• 💡 Iota integers (Go)
• 💡 No var keyword (Julia/Python)
• 💡 Custom prefix/infix/postfix operators (Julia)
• 💡 Multiple dispatch (Julia)
• 💡 Big Integers (Julia/Python)
• 💡 Arbitrary precision constants (Go)
• 💡 Fixed point arithmetic
• 💡 Bit-shifting (Julia)
• 💡 Mutating assignment (Julia)
• 💡 Numeric math functions (Julia)
• 💡 Broadcasting, i.e., element-wise operations (Julia)
• 💡 Rational numbers (Julia)
• 💡 Unicode (Rust/Julia)
• 💡 String interpolation (Scala)
• 💡 String concatenation (Scala)
• 💡 Compact function definitions (Julia)
• 💡 Variable arguments (Julia)
• 💡 Optional arguments (Julia)
• 💡 Named arguments (Julia)
• 💡 do keyword (Julia)
• 💡 Function composition ∘ (Julia)
• 💡 Function chaining |> (Julia)
• 💡 Ternary conditional operator (Julia)
• 💡 Exceptions (Julia)
• 💡 Explicit modules (Rust/Julia)
• 💡 Records and Row polymorphism (OCaml)
• 💡 Lists (OCaml/Erlang)
• 💡 Singleton types (Julia/Scala)
• 💡 Recursive data types (Julia/Scala/Go)
• 💡 Doc-comments (Scala/Julia/Rust)
• 👍 Comprehensions (Julia)
• 💡 Missing values (Julia, Python)
• 💡 Partial functions (functions which throw errors) and try-else (Pony)
• 💡 Unsafe addition +~, partial addition +?, checked addition + (Pony)
• 💡 with-blocks for disposal of objects (Pony)
• 💡 apply functions (Pony, Scala)
• 💡 match-else (Pony)
• 💡 None (nil) toDefault` coalescing operator (Swift)
• 💡 unless blocks (Elixir)
• 💡 map-literals %{key => val}(Elixir)
• 💡 map-update %{map | key => val}(Elixir)
• 💡 explicit shadowing ^x = y(Elixir)