{"action":"created","issue":{"url":"https://api.github.com/repos/ozra/onyx-lang/issues/77","repository_url":"https://api.github.com/repos/ozra/onyx-lang","labels_url":"https://api.github.com/repos/ozra/onyx-lang/issues/77/labels{/name}","comments_url":"https://api.github.com/repos/ozra/onyx-lang/issues/77/comments","events_url":"https://api.github.com/repos/ozra/onyx-lang/issues/77/events","html_url":"https://github.com/ozra/onyx-lang/issues/77","id":147139099,"number":77,"title":"Syntax Overhaul - Minimal Formalism","user":{"login":"ozra","id":563674,"avatar_url":"https://avatars.githubusercontent.com/u/563674?v=3","gravatar_id":"","url":"https://api.github.com/users/ozra","html_url":"https://github.com/ozra","followers_url":"https://api.github.com/users/ozra/followers","following_url":"https://api.github.com/users/ozra/following{/other_user}","gists_url":"https://api.github.com/users/ozra/gists{/gist_id}","starred_url":"https://api.github.com/users/ozra/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/ozra/subscriptions","organizations_url":"https://api.github.com/users/ozra/orgs","repos_url":"https://api.github.com/users/ozra/repos","events_url":"https://api.github.com/users/ozra/events{/privacy}","received_events_url":"https://api.github.com/users/ozra/received_events","type":"User","site_admin":false},"labels":[{"url":"https://api.github.com/repos/ozra/onyx-lang/labels/accepted-for-impl","name":"accepted-for-impl","color":"d2ffc6"},{"url":"https://api.github.com/repos/ozra/onyx-lang/labels/breaking","name":"breaking","color":"ff6644"},{"url":"https://api.github.com/repos/ozra/onyx-lang/labels/RFC","name":"RFC","color":"000000"}],"state":"open","locked":false,"assignee":null,"milestone":null,"comments":12,"created_at":"2016-04-09T15:39:49Z","updated_at":"2016-04-11T00:48:13Z","closed_at":null,"body":"This sprung out of thinking in #18.\r\n\r\nThe idea is that, for high performance coders, beacons need not be screaming, these coders navigate the code space more easily, and so the important identifying properties of code (non formal parts) are more important: identifiers and the like, unnecessary keywords gets in the way for this category of people.\r\n\r\nFor those coders with a slightly lower spatial capability, science seems to show that they might feel \"visually lost at sea\" with minimal beacons - they need bigger trunks to \"visually hold on to\". For that reason the syntax can be used with type-defs, module-defs etc. prefixed with keywords - as is common in most all languages today.\r\nIn other words these can be magically inserted/removed with the stylizer, so they can be on in repo-style, but off in you work-cache-dir where _you_ edit.\r\n\r\nThere's an alternative example of the first case as a last example with just a slight variation which looks better for certain cases.\r\n\r\nDisclaimer: this is show-case pseudo code, naturally not tested.\r\n\r\n## First off, the Efficient Minimal Formalism Syntax: ##\r\n```onyx\r\n(number)r    =  Real _\r\n(number)f    =  _f32\r\n(number)d    =  _f64\r\n\r\nMetrics.Suffixes<U = 1.0>:\r\n   BaseUnitRelToMeter = U\r\n\r\n   -- literal suffixes are template macros, applied to literals, so they're\r\n   -- defined like macros with the name in suffix position\r\n   (number)km    =  Real _ * 1000 * BaseUnitRelToMeter\r\n   (number)m     =  Real _ * 1 * BaseUnitRelToMeter\r\n   (number)dm    =  Real _ * 0.1 * BaseUnitRelToMeter\r\n   (number)cm    =  Real _ * 0.01 * BaseUnitRelToMeter\r\n   (number)mm    =  Real _ * 0.001 * BaseUnitRelToMeter\r\n   (number)in    =  Real _ * 0.0254 * BaseUnitRelToMeter\r\n   (number)ft    =  Real _ * 0.3048 * BaseUnitRelToMeter\r\n   (number)cubit =  raise \"Really? Sumerian, Hebrew, Egyptian, or...\"\r\n\r\nTime.Suffixes<U = 1000>:\r\n   ResolutionOfSecond = U\r\n\r\n   (number)s    =  Real _ * ResolutionOfSecond\r\n   (number)m    =  Real _ * 60 * ResolutionOfSecond  -- notice the clash with \"m\" above\r\n   (number)min  =  Real _ * 60 * ResolutionOfSecond\r\n   (number)h    =  Real _ * 60 * 60 * ResolutionOfSecond\r\n   (number)day  =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n   (number)days =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n\r\n-- A module is a \"heading\", so it should look like one\r\nEngineering:\r\n   Materials:\r\n      Suffixes:\r\n         (number)C = Real\r\n         (number)K = Real\r\n         (number)W = Real\r\n\r\n      SpecialSuffixes:\r\n         (integer)X = Trixter _\r\n\r\n      All: include Materials, Suffixes\r\n\r\n      -- enums are clean to express\r\n      Categories <: Enum\r\n         Insulators\r\n         Conductors\r\n         Carriers\r\n         Structural\r\n\r\n      -- \"flag-enums\" are clean to express\r\n      Properties <: Flags\r\n         Brittle\r\n         Pliable\r\n         Transparent\r\n         Translucent\r\n         Opaque\r\n         Reflective\r\n         Matte\r\n         Dark\r\n         Bright\r\n\r\n      -- A \"value\" / \"struct\" type is clean to express\r\n      Atom <: Value\r\n         @number = 0r\r\n         init(...) ->\r\n\r\n      -- Never have to specify that it is a value inherited type, that's of\r\n      -- course derived\r\n      FatAtom <: Atom\r\n         @certainty = 0r\r\n         init(...) ->\r\n\r\n      -- perhaps a nest-starter keyword 'for' applying only to the next\r\n      -- construct, avoiding indentation where it's only cluttering:\r\n      using Suffixes for\r\n      -- a standard reference type\r\n      Material <:\r\n         @name       Tag               'get\r\n         @properties Properties        'set 'set\r\n         @categories Categories        'get 'set\r\n         @k                     = 1K   'get\r\n         @density               = 0Kg  'get\r\n\r\n         init(@name, ...) ->\r\n\r\n      end Material\r\n\r\n      -- some alternatives for alias notation\r\n      MaterialAlias1 :> Material\r\n      MaterialAlias2 := Material\r\n      MaterialAlias3 ≡ Material\r\n\r\n      -- the terseness of simple template macros\r\n      material(name, k) =\r\n         {=name.id=} = Material #{=name.id=}, k: {=k=}\r\n         materials-list << {=name.id=}\r\n      end\r\n\r\n      -- the beauty of working with AST-nodes with indent call syntax\r\n      material-ast-macro(name, k) 'ast =\r\n         [\r\n         Assign\r\n            name.value\r\n            Call\r\n               \"new\"\r\n               \"Material\"\r\n               [ Arg Var name.value ] 'AstNode\r\n               named-args: [ NamedArg \"k\", k.value ]\r\n         Call\r\n            \"<<\"\r\n            \"materials-list\"\r\n            [ Arg Var name.value ] 'AstNode\r\n         ]\r\n      end\r\n\r\n      materials-list = [0 x Material]\r\n\r\n      -- \"begins\", which is old news, opens the nesting of the construct from\r\n      -- this point on in the scope\r\n      using Suffixes begins\r\n\r\n      material Water,         0.58K\r\n      material Copper,        400K\r\n      material Aluminium,     210K\r\n      material Silver,        429K\r\n      material Lead,          34K\r\n\r\n      material Air,           0.024K\r\n      material AirFilm,       0K  -- should rather use nil here of course\r\n      material AirGap,        0K  -- should rather use nil here of course\r\n\r\n      material Glass,         1K -- 0.96 - 1.04\r\n      material GlassWool,     0.04K -- 0.96 - 1.04\r\n      material FiberGlass,    0.04K\r\n      material UrethaneFoam,  0.04K\r\n      material EPS,           0.03K\r\n\r\n   using Metrics.Suffixes<1r>, Materials.All begins\r\n\r\n   -- type def without super-type may look a _little_ bit funny, but is\r\n   -- alright\r\n   Barrier <:\r\n      @w        = 10mm  'get\r\n      @h        = 10mm  'get\r\n      @d        = 10mm  'get\r\n      @material = Water 'get\r\n      @kmm      = 0K    'get\r\n      @foo      = \"foo\"\r\n\r\n      init(@w, @h, @d, @material) ->\r\n         @kmm = @material.k * (1mm * 1mm) -- stored in k/mm2 instead of k/m2\r\n\r\n   -- end token can match starting name for extra clarity and structure safety\r\n   end Barrier\r\n\r\n   -- A function not really doing anything useful (calculating u would be)\r\n   bridge-k-values(barriers List<Barrier>, t-in, t-out) ->\r\n      for b in barriers => say \"{b.class}, {b.material.name}, {b.material.k}, {b.kmm}\"\r\n      barriers.map ~.kmm\r\n\r\nend Engineering\r\n\r\n\r\n\r\n\r\ninclude Engineering\r\n\r\n-- in this case the below \"using\" has the same _practical effect_ as including\r\n-- Metrics modules generic param kept as default\r\n-- could have used `begins` here, but then we could also just have `include`d\r\nusing Materials.All, Metric.Suffixes\r\n\r\n   -- below would benefit from the proposed 'commas omitable after literals'\r\n   my-barriers = [\r\n      Barrier 10mm, 13mm, 0.1mm, Aluminium\r\n      Barrier 10mm, 13mm, 0.1mm, Zink\r\n      Barrier 10mm, 13mm, 1mm,   Aluminium\r\n      Barrier 10mm, 13mm, 13mm,  Water\r\n   ]\r\n\r\n   say bridge-k-values\r\n      my-barriers\r\n      30C\r\n      25C\r\n\r\n   good-insulators = materials-list.filter ~.k < 0.05K\r\n   good-thermal-conductors = materials-list.filter ~.k > 200K\r\n\r\n```\r\n\r\n## The Common Keyword Prefixed Style ##\r\n```onyx\r\nsuffix (number)r    =  Real _\r\nsuffix (number)f    =  _f32\r\nsuffix (number)d    =  _f64\r\n\r\nmodule Metrics.Suffixes<U = 1.0>\r\n   BaseUnitRelToMeter = U\r\n\r\n   -- literal suffixes are template macros, applied to literals, so they're\r\n   -- defined like macros with the name in suffix position\r\n   suffix (number)km    =  Real _ * 1000 * BaseUnitRelToMeter\r\n   suffix (number)m     =  Real _ * 1 * BaseUnitRelToMeter\r\n   suffix (number)dm    =  Real _ * 0.1 * BaseUnitRelToMeter\r\n   suffix (number)cm    =  Real _ * 0.01 * BaseUnitRelToMeter\r\n   suffix (number)mm    =  Real _ * 0.001 * BaseUnitRelToMeter\r\n   suffix (number)in    =  Real _ * 0.0254 * BaseUnitRelToMeter\r\n   suffix (number)ft    =  Real _ * 0.3048 * BaseUnitRelToMeter\r\n   suffix (number)cubit =  raise \"Really? Sumerian, Hebrew, Egyptian, or...\"\r\n\r\nmodule Time.Suffixes<U = 1000>\r\n   ResolutionOfSecond = U\r\n\r\n   suffix (number)s    =  Real _ * ResolutionOfSecond\r\n   suffix (number)m    =  Real _ * 60 * ResolutionOfSecond  -- notice the clash with \"m\" above\r\n   suffix (number)min  =  Real _ * 60 * ResolutionOfSecond\r\n   suffix (number)h    =  Real _ * 60 * 60 * ResolutionOfSecond\r\n   suffix (number)day  =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n   suffix (number)days =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n\r\n-- A module is a \"heading\", so it should look like one\r\nmodule Engineering\r\n   module Materials\r\n      module Suffixes\r\n         suffix (number)C = Real\r\n         suffix (number)K = Real\r\n         suffix (number)W = Real\r\n\r\n      module SpecialSuffixes\r\n         suffix (integer)X = Trixter _\r\n\r\n      module All include Materials, Suffixes\r\n\r\n      -- enums are clean to express\r\n      type Categories <: Enum\r\n         Insulators\r\n         Conductors\r\n         Carriers\r\n         Structural\r\n\r\n      -- \"flag-enums\" are clean to express\r\n      type Properties <: Flags\r\n         Brittle\r\n         Pliable\r\n         Transparent\r\n         Translucent\r\n         Opaque\r\n         Reflective\r\n         Matte\r\n         Dark\r\n         Bright\r\n\r\n      -- A \"value\" / \"struct\" type is clean to express\r\n      type Atom <: Value\r\n         @number = 0r\r\n         init(...) ->\r\n\r\n      -- Never have to specify that it is a value inherited type, that's of\r\n      -- course derived\r\n      type FatAtom <: Atom\r\n         @certainty = 0r\r\n         init(...) ->\r\n\r\n      -- perhaps a nest-starter keyword 'for' applying only to the next\r\n      -- construct, avoiding indentation where it's only cluttering:\r\n      using Suffixes for\r\n      -- a standard reference type\r\n      type Material <:\r\n         @name       Tag               'get\r\n         @properties Properties        'set 'set\r\n         @categories Categories        'get 'set\r\n         @k                     = 1K   'get\r\n         @density               = 0Kg  'get\r\n\r\n         init(@name, ...) ->\r\n\r\n      end Material\r\n\r\n      -- some alternatives for alias notation\r\n      type MaterialAlias1 :> Material\r\n      type MaterialAlias2 := Material\r\n      type MaterialAlias3 ≡ Material\r\n\r\n      -- the terseness of simple template macros\r\n      material(name, k) =\r\n         {=name.id=} = Material #{=name.id=}, k: {=k=}\r\n         materials-list << {=name.id=}\r\n      end\r\n\r\n      -- the beauty of working with AST-nodes with indent call syntax\r\n      material-ast-macro(name, k) 'ast =\r\n         [\r\n         Assign\r\n            name.value\r\n            Call\r\n               \"new\"\r\n               \"Material\"\r\n               [ Arg Var name.value ] 'AstNode\r\n               named-args: [ NamedArg \"k\", k.value ]\r\n         Call\r\n            \"<<\"\r\n            \"materials-list\"\r\n            [ Arg Var name.value ] 'AstNode\r\n         ]\r\n      end\r\n\r\n      materials-list = [0 x Material]\r\n\r\n      -- \"begins\", which is old news, opens the nesting of the construct from\r\n      -- this point on in the scope\r\n      using Suffixes begins\r\n\r\n      material Water,         0.58K\r\n      material Copper,        400K\r\n      material Aluminium,     210K\r\n      material Silver,        429K\r\n      material Lead,          34K\r\n\r\n      material Air,           0.024K\r\n      material AirFilm,       0K  -- should rather use nil here of course\r\n      material AirGap,        0K  -- should rather use nil here of course\r\n\r\n      material Glass,         1K -- 0.96 - 1.04\r\n      material GlassWool,     0.04K -- 0.96 - 1.04\r\n      material FiberGlass,    0.04K\r\n      material UrethaneFoam,  0.04K\r\n      material EPS,           0.03K\r\n\r\n   using Metrics.Suffixes<1r>, Materials.All begins\r\n\r\n   -- type def without super-type may look a _little_ bit funny, but is\r\n   -- alright\r\n   type Barrier <:\r\n      @w        = 10mm  'get\r\n      @h        = 10mm  'get\r\n      @d        = 10mm  'get\r\n      @material = Water 'get\r\n      @kmm      = 0K    'get\r\n      @foo      = \"foo\"\r\n\r\n      init(@w, @h, @d, @material) ->\r\n         @kmm = @material.k * (1mm * 1mm) -- stored in k/mm2 instead of k/m2\r\n\r\n   -- end token can match starting name for extra clarity and structure safety\r\n   end Barrier\r\n\r\n   -- A function not really doing anything useful (calculating u would be)\r\n   bridge-k-values(barriers List<Barrier>, t-in, t-out) ->\r\n      for b in barriers => say \"{b.class}, {b.material.name}, {b.material.k}, {b.kmm}\"\r\n      barriers.map ~.kmm\r\n\r\nend Engineering\r\n\r\n\r\n\r\n\r\ninclude Engineering\r\n\r\n-- in this case the below \"using\" has the same _practical effect_ as including\r\n-- Metrics modules generic param kept as default\r\n-- could have used `begins` here, but then we could also just have `include`d\r\nusing Materials.All, Metric.Suffixes\r\n\r\n   -- below would benefit from the proposed 'commas omitable after literals'\r\n   my-barriers = [\r\n      Barrier 10mm, 13mm, 0.1mm, Aluminium\r\n      Barrier 10mm, 13mm, 0.1mm, Zink\r\n      Barrier 10mm, 13mm, 1mm,   Aluminium\r\n      Barrier 10mm, 13mm, 13mm,  Water\r\n   ]\r\n\r\n   say bridge-k-values\r\n      my-barriers\r\n      30C\r\n      25C\r\n\r\n   good-insulators = materials-list.filter ~.k < 0.05K\r\n   good-thermal-conductors = materials-list.filter ~.k > 200K\r\n```\r\n\r\n\r\n## Terse Style - A Variation ##\r\n\r\nThe trailing `<:` looks funny. So it might be better to have `<:` mean extend / show subtype/supertype relation, and `::` (or something else!) to designate beginning of type description body. I don't like the double colon really - it might cause confusion in relation to other languages, in any event the token must be distinct from single colon and arrow.\r\n\r\n### This way: ###\r\n```onyx\r\nAny :: +(other MyType) -> self + other.the-value\r\n\r\nMyTypeWithNoSuperType ::\r\n   @some-val\r\n   init(...) ->\r\n\r\n```\r\n\r\n### Otherwise: ###\r\n- (note additional separating colon for one-liner)\r\n```onyx\r\nAny <: : +(other MyType) -> self + other.the-value\r\n\r\nMyTypeWithNoSuperType <:\r\n   @some-val\r\n   init(...) ->\r\n\r\n```\r\n\r\n### Compare Keyword Prefixed: ###\r\n```onyx\r\ntype Any : +(other MyType) -> self + other.the-value\r\n\r\ntype MyTypeWithNoSuperType\r\n   @some-val\r\n   init(...) ->\r\n\r\n```\r\n\r\n### Compare Crystal: ###\r\n```text\r\nclass Object\r\n  def +(other : MyType)\r\n    self + other.the_value\r\n  end\r\nend\r\n\r\nclass MyTypeWithNoSuperType\r\n   @some_val\r\n   def initialize(@some_val)\r\n   end\r\nend\r\n\r\n```\r\n\r\n### The full blown show-case again: ###\r\n```onyx\r\n(number)r    =  Real _\r\n(number)f    =  _f32\r\n(number)d    =  _f64\r\n\r\nMetrics.Suffixes<U = 1.0>:\r\n   BaseUnitRelToMeter = U\r\n\r\n   -- literal suffixes are template macros, applied to literals, so they're\r\n   -- defined like macros with the name in position\r\n   (number)km    =  Real _ * 1000 * BaseUnitRelToMeter\r\n   (number)m     =  Real _ * 1 * BaseUnitRelToMeter\r\n   (number)dm    =  Real _ * 0.1 * BaseUnitRelToMeter\r\n   (number)cm    =  Real _ * 0.01 * BaseUnitRelToMeter\r\n   (number)mm    =  Real _ * 0.001 * BaseUnitRelToMeter\r\n   (number)in    =  Real _ * 0.0254 * BaseUnitRelToMeter\r\n   (number)ft    =  Real _ * 0.3048 * BaseUnitRelToMeter\r\n   (number)cubit =  raise \"Really? Sumerian, Hebrew, Egyptian, or... cubit is a deprecated unit of measurement for {_}\"\r\n\r\nTime.Suffixes<U = 1000>:\r\n   ResolutionOfSecond = U\r\n\r\n   (number)s    =  Real _ * ResolutionOfSecond\r\n   (number)m    =  Real _ * 60 * ResolutionOfSecond  -- notice the clash with \"m\" for \"meter\" above\r\n   (number)min  =  Real _ * 60 * ResolutionOfSecond\r\n   (number)h    =  Real _ * 60 * 60 * ResolutionOfSecond\r\n   (number)day  =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n   (number)days =  Real _ * 24 * 60 * 60 * ResolutionOfSecond\r\n\r\n-- A is a \"heading\", so it should look like one\r\nEngineering:\r\n   Materials:\r\n      Suffixes:\r\n         (number)C = Real\r\n         (number)K = Real\r\n         (number)W = Real\r\n\r\n      SpecialSuffixes:\r\n         (integer)X = Trixter _\r\n\r\n      All: include Materials, Suffixes\r\n\r\n      -- enums are clean to express\r\n      Categories <: Enum ::\r\n         Insulators\r\n         Conductors\r\n         Carriers\r\n         Structural\r\n\r\n      -- \"flag-enums\" are clean to express\r\n      Properties <: Flags ::\r\n         Brittle\r\n         Pliable\r\n         Transparent\r\n         Translucent\r\n         Opaque\r\n         Reflective\r\n         Matte\r\n         Dark\r\n         Bright\r\n\r\n      -- A \"value\" / \"struct\" is clean to express\r\n      Atom <: Value ::\r\n         @number = 0r\r\n         init(...) ->\r\n\r\n      -- Never have to specify that it is a value inherited type, that's of\r\n      -- course derived\r\n      FatAtom <: Atom ::\r\n         @certainty = 0r\r\n         init(...) ->\r\n\r\n      -- perhaps a nest-starter keyword 'for' applying only to the next\r\n      -- construct, avoiding indentation where it's only cluttering:\r\n      using Suffixes for\r\n      -- a standard reference type\r\n      Material ::\r\n         @name       Tag               'get\r\n         @properties Properties        'set 'set\r\n         @categories Categories        'get 'set\r\n         @k                     = 1K   'get\r\n         @density               = 0Kg  'get\r\n\r\n         init(@name, ...) ->\r\n\r\n      end Material\r\n\r\n      -- some alternatives for alias notation\r\n      MaterialAlias1 :> Material\r\n      MaterialAlias2 := Material\r\n      MaterialAlias3 ≡ Material\r\n\r\n      -- the terseness of simple template macros\r\n      material(name, k) =\r\n         {=name.id=} = Material #{=name.id=}, k: {=k=}\r\n         materials-list << {=name.id=}\r\n      end\r\n\r\n      -- the beauty of working with AST-nodes with indent call syntax\r\n      material-ast-macro(name, k) 'ast =\r\n         [\r\n         Assign\r\n            name.value\r\n            Call\r\n               \"new\"\r\n               \"Material\"\r\n               [ Arg Var name.value ] 'AstNode\r\n               named-args: [ NamedArg \"k\", k.value ]\r\n         Call\r\n            \"<<\"\r\n            \"materials-list\"\r\n            [ Arg Var name.value ] 'AstNode\r\n         ]\r\n      end\r\n\r\n      materials-list = [0 x Material]\r\n\r\n      -- \"begins\", which is old news, opens the nesting of the construct from\r\n      -- this point on in the scope\r\n      using Suffixes begins\r\n\r\n      material Water,         0.58K\r\n      material Copper,        400K\r\n      material Aluminium,     210K\r\n      material Silver,        429K\r\n      material Lead,          34K\r\n\r\n      material Air,           0.024K\r\n      material AirFilm,       0K  -- should rather use nil here of course\r\n      material AirGap,        0K  -- should rather use nil here of course\r\n\r\n      material Glass,         1K -- 0.96 - 1.04\r\n      material GlassWool,     0.04K -- 0.96 - 1.04\r\n      material FiberGlass,    0.04K\r\n      material UrethaneFoam,  0.04K\r\n      material EPS,           0.03K\r\n\r\n   using Metrics.Suffixes<1r>, Materials.All begins\r\n\r\n   -- def without super-may look a _little_ bit funny, but is\r\n   -- alright\r\n   Barrier ::\r\n      @w        = 10mm  'get\r\n      @h        = 10mm  'get\r\n      @d        = 10mm  'get\r\n      @material = Water 'get\r\n      @kmm      = 0K    'get\r\n      @foo      = \"foo\"\r\n\r\n      init(@w, @h, @d, @material) ->\r\n         @kmm = @material.k * (1mm * 1mm) -- stored in k/mm2 instead of k/m2\r\n\r\n   -- end token can match starting name for extra clarity and structure safety\r\n   end Barrier\r\n\r\n   -- A function not really doing anything useful (calculating u would be)\r\n   bridge-k-values(barriers List<Barrier>, t-in, t-out) ->\r\n      for b in barriers => say \"{b.class}, {b.material.name}, {b.material.k}, {b.kmm}\"\r\n      barriers.map ~.kmm\r\n\r\nend Engineering\r\n\r\n\r\n\r\n\r\ninclude Engineering\r\n\r\n-- in this case the below \"using\" has the same _practical effect_ as including\r\n-- Metrics modules generic param kept as default\r\n-- could have used `begins` here, but then we could also just have `include`d\r\nusing Materials.All, Metric.Suffixes\r\n\r\n   -- below would benefit from the proposed\r\n   my-barriers = [\r\n      Barrier 10mm, 13mm, 0.1mm, Aluminium\r\n      Barrier 10mm, 13mm, 0.1mm, Zink\r\n      Barrier 10mm, 13mm, 1mm,   Aluminium\r\n      Barrier 10mm, 13mm, 13mm,  Water\r\n   ]\r\n\r\n   say bridge-k-values\r\n      my-barriers\r\n      30C\r\n      25C\r\n\r\n   good-insulators = materials-list.filter ~.k < 0.05K\r\n   good-thermal-conductors = materials-list.filter ~.k > 200K\r\n\r\n```\r\n\r\nThe terse/clean style is surprisingly distinct in its' expression: I hacked together a grammar for sublimetext in about 30 minutes, and baam, immediately you could \"jump to definition\", etc. in the editor (and highlighting of course).\r\n\r\n"},"comment":{"url":"https://api.github.com/repos/ozra/onyx-lang/issues/comments/208103692","html_url":"https://github.com/ozra/onyx-lang/issues/77#issuecomment-208103692","issue_url":"https://api.github.com/repos/ozra/onyx-lang/issues/77","id":208103692,"user":{"login":"stugol","id":1113153,"avatar_url":"https://avatars.githubusercontent.com/u/1113153?v=3","gravatar_id":"","url":"https://api.github.com/users/stugol","html_url":"https://github.com/stugol","followers_url":"https://api.github.com/users/stugol/followers","following_url":"https://api.github.com/users/stugol/following{/other_user}","gists_url":"https://api.github.com/users/stugol/gists{/gist_id}","starred_url":"https://api.github.com/users/stugol/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/stugol/subscriptions","organizations_url":"https://api.github.com/users/stugol/orgs","repos_url":"https://api.github.com/users/stugol/repos","events_url":"https://api.github.com/users/stugol/events{/privacy}","received_events_url":"https://api.github.com/users/stugol/received_events","type":"User","site_admin":false},"created_at":"2016-04-11T00:48:12Z","updated_at":"2016-04-11T00:48:12Z","body":"`Object` and `Value` are probably the least irritating of the lot, but I don't think we should use any of them. I shouldn't have to specify the base class when monkeypatching, neither should I have to specify a base class for an object that doesn't have one!\r\n\r\nNo, I think keep the trailing `<:` for a multiline class, and use `<::` for a single-line class."}}