cstyle.sc

###### 'C-style' syntax (braces and semicolons) ######
 -> return statements needed (except in one-expression lambdas)

// function := 'fn' ['<' Types... '>'] ident '(' Args... ')' ['->' RetType] block-statement
// local-function := function
// lambda := '(' args... ')' '->' statement
// args := [ arg { , arg } ]
// arg := ident [['::'] type]
// if 'statement' is an expression, then automatically 'return' it!
// 'statement' can be a block as well! (-> multiple statements...)

// verbose
fn <T, P>
filter(arr :: [T], pred :: P) -> [T] {
  var result = [] :: type(arr);
  arr.each((v, i) -> if pred(v) { result.push(v) });
  return result
}

// '::' is not compulsory
filter(arr [T], pred T -> bool) -> [T] { ... }

// concise
fn filter(arr, pred) {
  var result = [] :: type(arr);
  arr.each((v, i) -> if pred(v) { result.push(v) });
  return result
}

lightweight.sc

###### 'Lightweight' syntax (whitespace-sensitive) ######
 -> expression language; value of last statement is automatically returned

// lambda := 'fn' ['(' args ')'] ['->' RetType] '=' expression
// args := [ arg { , arg } ]
// arg := ident ['::' type]
// expression can be a 'one-liner' or a block

// verbose
fn<T>
filter (arr :: [T], pred :: T -> bool) -> [T] =
  var result = [] :: [T]
  arr.each(
    fn (v :: T) -> () =
      if pred(v) then
        result.push(v)
      ()
  )
  result

// concise
fn filter (arr, pred) = 
  var result = [] :: type(arr)
  arr.each(
    fn (v) =
      if pred(v) then
        result.push(v)
  )
  result