mimiumの言語仕様#

このページでは、mimium言語の基本的文法(シンタックスおよびセマンティクス)について説明します。

コメントアウト#

Rust、C++やJavaScriptと同様、行中の//より右側はコメントとして扱われます。 また/* */のように囲むと、複数行をまとめてコメントアウトできます。

変数宣言、代入#

letキーワードに続けて名前、=、代入したい値を記述すると、変数が作られます。

let mynumber = 1000

すでにスコープ中に同名の変数があった場合、そのスコープ内で一番新しくlet宣言された変数が参照されます。（元々の変数に対しては影響を与えません。）これは、シャドーイングと呼ばれます。

fn dsp(x){
  let x = 1.0
  x //x is always 1.0 whatever argument is given
}

letなしで変数を代入すると、すでに宣言されている変数に新たに値を代入します。

let mynumber = 1000
mynumber = 2000 // 2000 is newly assigned to mynumber

型#

型とは変数などのデータを数値や文字列など目的に応じて区別するための概念です。 mimiumは静的型付け言語と呼ばれる、コンパイル時に（音を実際に鳴らす前）すべての型が決定される言語です。

静的型付け言語は一般的に、実行中に型をチェックする言語よりも実行速度の面で有利です。その一方、型の指定を手動で行う場合は記述が長くなりがちというデメリットも存在しますが、mimiumでは型推論と呼ばれる、文脈から型が自動的に決定できる場合は型注釈を省略できる機能が存在しているので、コードを簡潔に保つことが可能です。

型にはそれ以上分解できない最小単位であるプリミティブ型と、複数の型を組み合わせて作る合成型（aggregate type）が存在します。

型の明示的な注釈は変数の宣言と関数の宣言時に可能です。 変数および関数のパラメータでは名前に続けて:（コロン）を挟み型名を書くことで指定可能です。

let myvar:float = 100

以下のように異なる型へ代入した場合はコンパイル時にエラーが発生します。

let myvar:string = 100

関数での型宣言では返り値をパラメータの括弧に続けて->を挟んで書くことで指定できます。

fn add(x:float,y:float)->float{
  x + y
}

このadd関数の場合、文脈からxとyがfloatであることを予測できる¹ので以下のように省略できます。

fn add(x,y){
  x+y
}

プリミティブ型#

mimiumにおけるプリミティブ型はfloatとstring、voidのみです。

mimiumでは数値型はfloat（内部的には64bit float）のみとなっています。 整数を利用するにはround、ceil、floor関数などを利用します。

string型の値は"hoge"のようにダブルクオーテーションで囲った文字列リテラルから生成できます。

用途は基本的には

1. Probe!マクロに渡してデバッグ用途に使う
2. Sampler_mono!マクロに渡してオーディオファイルを読み込む

のいずれかに限られています。よりアドバンスドな使い方としては、文字列自体をmimium上で解析して別のDSLを埋め込むということができます。examples/uzulang.mmmでしようしているmini関数（mini notation記法のサブセット）を参照してください。

voidは値を持たない型で、関数の返り値が存在しないことを明示するのに使用します。

合成型#

関数型#

関数型は(T1,T2,...)->Tのようなシグネチャで表記します。

配列#

配列は、同じ型の値を複数個連続して格納できる型です。[]（アングルブラケット）で囲んだカンマ区切りの値で生成できます。

let myarr = [1,2,3,4,5,6,7,8,9,10]

後述するタプルのような合成型も配列の要素にできますが、配列のそれぞれの要素は全て同じ型でなければいけません。

let tuparr = [(1,2),(3,4)]

配列型の値にmyarr[0]のようにアングルブラケットで0基準のインデックスを指定することで配列の値を取り出すことができます。

let arr_content = myarr[0] //arr_content should be 1

len()という関数を使用することで、配列の要素数を実行中に取得することができます。

let len = len(myarr) // len should be 10.0

配列は現在、サイズ固定かつイミュータブルです。配列の後ろに値を追加していくような操作はできません。また境界チェックもないため範囲外へのアクセスはクラッシュを引き起こします。

タプル#

タプルは、異なる型を1つにまとめた値です。変数を()（丸括弧）で囲んでカンマ区切りの変数を入れることで生成できます。 タプルは配列とも似ていますが、各要素で異なる型を持つことができます。

let mytup = (100,200,300)

左辺値にカンマ区切りの変数を置くことでタプルの値を取り出すことができます。

let (one,two,three) = mytup

この場合、型を明示するときは各要素にコロンをつけるのではなく、パターン全体からコロンに続けて方を表示する必要があります。

左辺値にカンマ区切りの変数を置くことでタプルの値を取り出すことができます。

let (one,two,three):(float,float,float) = mytup

これは、ドット演算子に数値インデックスを組み合わせてアクセスする記述とイコールです。

let one = mytup.0
let two = mutup.1
let three = mytup.2

タプルはmimiumの中では典型的に信号処理でステレオやマルチチャンネルなどのオーディオ信号のチャンネルをまとめて扱うために利用されています。

足し算、引き算などの基本演算子は普通数値型同士のみに限られていますが、例外として数値型のみを要素に持つタプルは、通常の数値と同じ演算子で、各要素同士の演算を行うことができます。

構造体（レコード型）#

mimium v3では、Elmに着想を得た構文を持つレコード型（他言語の構造体に相当）を導入しています。レコードを使うことで、名前付きフィールドで関連するデータをグループ化でき、コードの可読性と保守性が向上します。

基本構文:

// 名前付きフィールドを持つレコードリテラル
let myadsr_param = { 
   attack = 100.0,
   decay = 200.0,
   sustain = 0.6,
   release = 2000.0,
}

// 型注釈はオプション
let myrecord = {
  freq:float = 440.0,
  amp = 0.5,
}

// 単一フィールドのレコードには末尾のカンマが必要
let singlerecord = {
  value = 100,
}

レコードフィールドへのアクセス:

// ドット演算子によるフィールドアクセス
let attack_time = myadsr_param.attack

// let束縛でのパターンマッチング
let {attack, decay, sustain, release} = myadsr_param

// アンダースコアを使った部分適用と組み合わせ
let myattack = myadsr_param |> _.attack

レコード更新構文:

レコードの変更版を作成することは関数型プログラミングでは一般的なパターンです。mimium v3では、レコードを更新するためのクリーンな構文を導入しています：

let myadsr = { attack = 0.0, decay = 10.0, sustain = 0.7, release = 10.0 }

// 特定のフィールドを更新し、他は変更しない
let newadsr = { myadsr <- attack = 4000.0, decay = 2000.0 }
// newadsr は { attack = 4000.0, decay = 10.0, sustain = 0.7, release = 10.0 }

// 元のレコードは変更されない（イミュータブルなセマンティクス）
// myadsr はまだ { attack = 0.0, decay = 10.0, sustain = 0.7, release = 10.0 }

レコード更新構文はシンタックスシュガーとして実装されており、関数型プログラミングのセマンティクスを保証します。既存のものを変更するのではなく、新しいレコードを作成します。

バリアント型#

バリアント(Tagged Union/Sum/Rustにおけるenum)型は、A,B,Cのいずれかの値が入っているという型です。

バリアントはmatch式で分解することができます。（match式は整数型やタプル型に対しても用いることができます）

type MyEnum = One | Two | Three

fn test(e: MyEnum) {
  match e {
    One => 1,
    Two => 2,
    Three => 3
  }
}

let x = test(One)  // 1

バリアントのそれぞれの値には、ペイロードを持たせることもできます。

type MyEnum = One(float) 
            | Two((float, float))
            | Three((float, float, float))

fn test(e: MyEnum) {
  match e {
    One(v) => v * 1,
    Two((x, y)) => x * 2 + y * 3,
    Three((x, y, z)) => x + y + z
  }
}

let x = test(One(3))           // 3
let y = test(Two((4, 5)))      // 23
let z = test(Three((6, 7, 8))) // 21

再帰バリアント#

バリアントは再帰する方を定義することも可能ですが、その際にはtype recでの明示的な宣言が必要です。

type rec List = Nil | Cons(float, List)

fn sum(list: List) -> float {
    match list {
        Nil => 0.0,
        Cons(head, tail) => head + sum(tail)
    }
}

fn dsp() -> float {
    let mylist = Cons(1.0, Cons(2.0, Cons(3.0, Nil)))
    sum(mylist)  // BoxClone automatically handles reference counting
}

型エイリアス#

タプルやレコードは型注釈が長いので、以下のような構文でエイリアスを作ることができます。

type alias FilterCoeffs = (float,float,float,float,float)

多段階計算（マクロ）#

mimium v3では、型安全なマクロシステムとして多段階計算機能が導入されています。これにより、コンパイル時にコードを生成し、効率的なオーディオ処理を実現できます。

多段階計算の詳細については、多段階計算（マクロ）のページを参照してください。

関数#

関数は、複数の値を取って新しい値を返すような、再利用可能な手続きをまとめたものです。

例として2つの値を足算して返すだけのadd関数を考えます。

fn add(x,y){
  x+y
}

mimiumでは関数が第一級の値として扱えます。これは、関数を変数に代入したり、関数を引数として受け取ったりできるということです。

たとえば、先ほどのadd関数の型注釈は(float,float)->floatのようになっています。先ほどのadd関数を変数に代入する場合は以下のように書けます。関数を関数のパラメータとして代入する場合は高階関数の項を参照してください。

let my_function:(float,float)->float = add

無名関数（ラムダ式）#

実は先ほどの関数宣言は以下のような、無名関数を変数に格納する構文へのエイリアスです。

let add = |x:float,y:float|->float {x+y}

このような関数を変数に代入しないまま直接呼び出すことも可能です。

println(|x,y|{x + y}(1,2)) //print "3"

パラメータパック#

mimium v3では、パラメータパック機能により、関数がタプルやレコードを引数として受け取り、自動的に個別のパラメータにアンパックできます。

タプルの場合:

fn add(a:float, b:float)->float {
  a + b
}

// 個別の引数での直接呼び出し
add(100, 200)  // 300を返す

// タプルの自動アンパック
add((100, 200))  // 300を返す

// パイプ演算子とシームレスに連携
(100, 200) |> add  // 300を返す

レコードの場合:

fn adsr(attack:float, decay:float, sustain:float, release:float)->float {
  // ADSRエンベロープの実装...
}

// レコードで呼び出し - フィールドの順序は任意
let params = { attack = 100, decay = 200, sustain = 0.7, release = 1000 }
adsr(params)

// またはインライン
adsr({ decay = 200, attack = 100, release = 1000, sustain = 0.7 })

この機能は、多くのパラメータを持つことが多いオーディオ処理関数で特に有用です。

デフォルト引数#

関数でパラメータのデフォルト値を指定できます：

fn foo(x = 100, y = 200) {
  x + y + 1
}

fn bar(x = 100, y) {
  x + y
}

fn dsp() {
  // 空のレコード{}を使ってすべてのデフォルトを受け入れる
  foo({}) +           // x=100, y=200を使用、301を返す
  bar({y = 300})      // x=100, y=300を使用、400を返す
  // 合計: 701
}

デフォルト値はパラメータパック構文と連携します。{}を使ってすべてのデフォルト値を受け入れ、上書きしたいパラメータのみを指定できます。

パイプ（|>）演算子#

mimiumではパイプ演算子|>利用することでa(b(c(d)))のようにネストした関数呼び出しをd |> c |> b |> aのように書き換えることができます。

パイプ演算子は他のどの演算子よりも低い結合順序を持っています。また、パイプの前後で改行が許されます。次の部分適用と組み合わせることで、データフローをわかりやすく表すことができます。

アンダースコア(_)による部分適用とマクロパイプ(||>)演算子#

マクロパイプ（||>）演算子は、パイプと似ていますがコンパイル時に解決されるパイプです。これは通常アンダースコア_によるコンパイル時部分適用と組み合わされて使います。

関数適用の引数にアンダースコア(_)を使用すると、その部分を新たな引数とした関数を作れます。例えば足し算のadd関数の、片方の引数を1で固定した新たな関数addoneを作るとしましょう。

例えば、fn lowpass(input,freq,q)のような関数があったとしましょう。これを通常のパイプで繋ごうとすると、このような表現になります。

use osc::sinwave
fn lowpass(input,freq,q){
  ...
}

fn dsp(){
  sinwave(440,0)
  |> |x|lowpass(x,2000,2)
}

これは一見上手くいきそうに見えますが、フィルターはうまく適用されません。なぜなら、|x|lowpass(x,2000,2)は、2000,2というパラメーターを部分的に適用した新しい関数を毎サンプル生成し直すという意味になってしまい、フィルターの内部状態が毎回リセットされてしまうからです。

代わりに、マクロパイプとアンダースコアを組み合わせて、このような形で使います。

fn dsp(){
  sinwave(440,0)
  ||> lowpass(_,2000,2)
}

マクロパイプ演算子a ||> b は、${`a |> b}の略で、アンダースコアを使った関数適用hoge(a,_,b)は `|x| hoge(a,$x,b)の略です。a ||> hoge(x,_,y)はコンパイル後にはhoge(x,a,y)に解決されるのです。

再帰によるループ#

名前のついている関数は自分自身を呼び出すことも可能です。

階乗を計算するfact関数は以下のように定義できます。

fn fact(input:float){
  if(input>0) 1 else input * fact(input-1)
}

再帰関数は無限ループを発生させる可能性があるので注意して使用してください。

letrec#

再帰関数はトップレベルでの関数定義のみで許され、letとラムダ式では表現することができません。ネストされた関数定義の中で再帰関数を定義したい場合、letの代わりにletrecを使用することで再帰関数を定義できます。

letrec fact = |input|{
  if(input>0) 1 else input * fact(input-1)
}

これはfnの構文と内部的に完全に等価です。注意点として、letrecで宣言する変数ではletのようにタプルを分解するようなパターンは受け取れません。

クロージャ#

TBD

式（expression）、文（statement）、ブロック#

関数などで使われていた中括弧{}で囲まれた文の集まりはブロックと呼ばれる単位です。文（statement）はほとんどの場合let a = b,x = yのような式の代入をする構文で構成されています。式（expression） は1000のような数字、mynumberのような変数シンボル、1+2*3のような演算式、add(x,y)のような返り値を持つ関数呼び出しなどで構成される単位です。

ブロックは実は式の1つです。 ブロックには複数の文を置くことができ、最後の1行の式を返り値として持ちます。

//mynumber should be 6
let mynumber = {
  let x = 2
  let y = 4
  x+y
}

条件分岐#

mimiumの条件分岐はif (condition) then_expression else else_expressionという構文を持っています。

condition、then_expression、else_expressionはすべて式です。 conditionの値が0より大きい時then_expression部分が、そうでなければelse_expressionが評価されます。

then/elseの部分をブロックとして表現すれば、以下のようにできます。

fn fact(input:float){
  if(input>0){
    1
  }else{
    input * fact(input-1)
  }
}

一方でif文自体も式として扱えるので、同じ構文を以下のように書き換えることもできます。

fn fact(input:float){
  if (input>0) 1 else input * fact(input-1)
}

モジュール#

モジュールは、関数機能の分割と隠蔽を行うための機能です。

Rustと同じように、pubをつけた関数やモジュールは、そのモジュールの外側に公開されます。

mod outer {
    mod inner {
        pub fn secret() {
            42.0
        }
    }
    pub fn exposed() {
        // Using relative path: inner::secret() instead of outer::inner::secret()
        inner::secret()
    }
}
fn dsp() {
    outer::exposed()
}

use構文を使うと、そのファイルの相対パスをまず検索し、見つからなければ~/.mimium/libの中から検索します。アスタリスク（*）を使うと、モジュール内で公開されたシンボルを全てインポートします。

use osc::sinwave
fn dsp(){
  sinwave(440,0)
}

BNFによる文法定義、演算子の優先順位など#

See https://github.com/mimium-org/mimium-rs/blob/dev/crates/lib/mimium-lang/src/compiler/parser/ebnf.md