slang.ohm

Sound {
  Line = Graph | Play | Comment

  /*
    A comment is any line that begins with #
  */

  Comment = "#" any+

  /*
    SOUND OBJECTS
    A sound object is a '@synth' variable. We
    can also access part of the sound's graph
    using dot notation, e.g. '@synth.osc1'.
    We'll only accept soundAccessors in a few
    places.
  */

  sound = "@" alnum+
  propertyAccessor = "." alnum+
  soundAccessor = sound propertyAccessor?
  
  /*
    FUNCTIONS
    A function is anything in parentheses. These
    will power blocks and arbitrary tools that
    might spit out lists, numbers, etc. The syntax
    is inspired by Clojure. Notice that the first
    type of sound argument is... a function! This
    enables is to write nested functions. Imagine:
    (notes (random (chord major E3)))
  */
  
  function = "(" listOf<soundArgument, delimiter> ")"
  soundArgument = function -- function
    | range -- range
    | list -- list
    | rhythm -- rhythm
    | float -- float
    | note -- note
    
  /*
    GRAPH LINES
    A graph is a sound declaration followed by
    one or more pipes that configure it. Graph
    declarations will be additive, e.g. two
    line with '@synth ~ (osc)' will create two
    oscillators.
    This definition is slightly longer than it
    needs to be so that we can make the first
    tilde optional. Either '@synth (osc tri)'
    or '@synth ~ (osc tri)' will be valid.
  */

  Graph = soundAccessor "~"? PolySoundBlock Pipe?

  /*
    Sound blocks look like functions, e.g.
    '(osc sine 1)'. You can string several
    together using pipes, which will literally
    pipe the sounds together.
  */

  PolySoundBlock = MonoSoundBlock ("+" MonoSoundBlock)*
  MonoSoundBlock = "(" listOf<soundArgument, delimiter> ")" name?
  name = ":" alnum+

  Pipe = ("~" PolySoundBlock)+

  /*
    PLAY LINES
    A play line is a play keyword (either 'play'
    or '>'), followed by the sound we want to play,
    followed by a pattern. Each pattern uses a
    different enclosing bracket. They could also
    use a SoundBlock-like definition I guess.
  */

  Play = PlayKeyword sound Pattern
  PlayKeyword = "play" | ">"

  /*
    PATTERNS
    The play line is expecting one or more function
    calls that determine what the sound does. Those
    might be things like (rhythm xox), (notes E3 D3),
    and (times 0.2 0.3 0.5). Determining what tools
    are possible should be a *runtime* concern, not
    a grammar-level concern.
  */

  Pattern = listOf<function, delimiter>

  /*
    PRIMITIVES
    Here are the primitive types we're working with.
  */

  list = "[" listOf<soundArgument, delimiter> "]"
  range = "[" int ".." int "]" -- number
    | "[" note ".." note "]" -- note

  delimiter = " "

  float = "-"? digit* "." digit+ -- fullFloat
    | "-"? digit "." -- dot
    | "-"? digit+ -- int
  
  int = "-"? digit+

  note = letter "#" digit+ -- sharp
    | letter "b" digit+ -- flat
    | alnum+ -- major
  
  rhythm = "r"? digit+ letter
}