Beyond D2

From D Wiki
Revision as of 04:47, 10 November 2013 by Timotheecour (talk | contribs) (→‎Features to drop)
Jump to: navigation, search

Motivation

This can be used as a centralized place to discuss parts of D2's design that are controversial or suboptimal in retrospect. Also discussed here are features that would be worthy of consideration in a hypothetical successor for D2, let's call it D3 (or E!). This page came up from email thread http://forum.dlang.org/post/ygmtislwwhfftiqrujan@forum.dlang.org.

Desirable properties:

  • remove redundant features & special syntax from language, prefer library solution whenever possible
  • increase syntax & feature orthogonality (no special case for strings, prefer explicit to implicit)
  • increase DRY-ness of code
  • make refactoring code easier
  • design grammar to be easy to parse and provide reference compiler as a library
  • feature AST macros to simplify a number of constructs
  • prefer automatic attribute inference over manual annotation

Clarity of target language is a more important role than to try to stay as close as possible to D2's syntax. Indeed, automatic translation tools can easily take care of this given that D is easy to parse (Dscanner can already do this, module caveats that'll eventually be fixed).

Features to drop

  • get rid of C-style expression lists in parenthesis; these would be reserved for tuples
  • strings: stop conflating range of code points with range of code units:
    • "foo" represents a range of code points
    • "foo".rep represents a range of code units, eg: immutable(char)[]
    • This would remove a *lot* of special case code in phobos and make it easier to write generic code, eg, would remove need for distinguishing ElementType vs ForeachType
    • I've discussed this in email:"iteration over a string"
    • Andrei mentioned it here as well: http://forum.dlang.org/post/l3h49k$b6$1@digitalmars.com : "It is my opinion that a better solution exists (in the form of making representation accessible only through a property .rep)"
  • get rid of @property
  • get rid of /**/ since we have nesting /++/
  • pragma(msg,) shouldn't insert "\n" (easy to add, impossible to remove)
  • remove 'version(foo)' syntax in favor of: static if(versions.foo), which is more orthogonal. versions is an implicitly imported module that contains (for example):
 version.osx=true 
 version.posix=true
 version.windows=false
 //plus other versions defined on command line
=> see https://github.com/timotheecour/dtools/blob/master/dtools/util/versions.d for a library solution

Safety

  • default is @safe/@pure ; attributes are automatically inferred and exported in di interface files

Separate Compilation

  • is virtual by default a good idea with separate compilation model?

Features to add

  • python style named parameter arguments
  • Yield return
  • R-value references
  • Safe references
  • language syntax for tuples; unify syntax for compile time tuples with runtime tuples
    • could follow DIP32 but use (a,b) syntax instead; we would get rid of C-style expression lists to enable this

Arrays and Ranges

  • builtin slices with begin..end:step or begin..end..step

Compilation

  • allow JIT code, to allow runtime eval statements (for REPL etc).
  • Compiler as a library (eg llvm/clang toolchain)
  • Compiler written in D2, and then bootstrapped from their as done in rust and many other languages

Tooling

Syntax changes

  • full UFCS support: foo.mixin, foo.assert, foo.stringof, foo.typeof
  • More lightweight syntax:
    • Go style a := b meaning auto a = b
    • semi-column optional
    • Go style lightweight if/while/etc expressions that don't require () around the if statement:
while x>=0 {...}

Language interop

  • Allow transparently including C headers in code as in Go; could use swig behind the scenes

More controversial features to add

  • store code as AST,
    • The 1st idea is to get rid of styleguides completely and allow people to read/write code with their preferred style. Codes gets stored and exchanged as AST; clients read the AST and converts it on the fly as source code in the user's preferred formatting.
    • speeds up compilation: only currently modified code needs to get translation from source to AST
    • More future proof and eases refactoring


Page originally created by Timothee Cour on 11/09/2013; copyright: public domain. TODO: add discussion/DIP/webpage links to each item

Retrieved from "https://wiki.dlang.org/?title=Beyond_D2&oldid=3155"