(cache) own language contest

自作言語で4つのお題を解こう!
提出したコードは下に表示されます. 投票日は後日公開されます.
参加・投票にはTwitterアカウントが必要です. 投票するかたは, 4つのお題のコードや解説をそれぞれ見て, 「普通」, 「良さそう」の2択と「難解そう」で投票します. その投票の集計の結果で, 自作言語の優秀作を選びます.

lang: Lit
creator: @uint256_t

GitHub: http://github.com/maekawatoshiki/lit-x86/tree/ast
ホームページ（未完成）: http://maekawatoshiki.github.io/lit-homepage

Lit はRuby風の書き方が出来る言語です。今のところはRubyどころかCにも劣る言語ですが、唯一勝てる点があります。
それは速度です。Lit はJITコンパイルをするので、C並みの速度で実行することが出来ます。
いつかは、Ruby互換を目指したいです（いつになるのやら

hello world

square

fibonacci number

Editor!

puts "Hello world!"

require "String"

def putHash h w
 for x in 1..h
  for y in 1..w
   print "#"
  end
  puts ""
end

str = gets
size = str_split str " "
putHash str_to_i(size[0]) str_to_i(size[1])

def fibo n
 if n == 0
  0 
 elsif n == 1
  1
 else 
  fibo(n - 1) + fibo(n - 2)
 end
end

puts fibo 40

lang: Lambia
creator: @phi16_

* 申し訳ないですが「こうなるといいな～」というコードで、今は動かないです・・・(その内動くようにします(おそらく))

言語はこの辺です : https://github.com/phi16/Lambia
「読めるラムダ計算」を作りたくて作ったものです。型は無いです。全てのプログラムは零または唯一の実行行を持ちます。
見た感じPre.IOが万能ですが、その実Primitiveであるもの以外は全て簡単に自作が可能・・・になるはずです。
IO周りを特殊な値として保持し、それが評価されたタイミングで諸々を動かすようにしようかなとおもってます。Haskellから演算子を取り除いたような言語ですね。
とてもおおきな問題点として評価がめちゃくちゃ遅いです。この辺はNatなどのデータ構造を少しPrimitiveにすることで解決したいと考えています。

コードの解説 : 1.自明 2.BindはMonadのBindです 3.Wikipediaのアレ 4.Splitでどうにかします (全体的にHaskellが分かれば分かるかと思います)

hello world

square

fibonacci number

Editor!

open Pre.IO

PutLine "Hello, World!"

open Pre.IO

Bind GetLine (\x.{
  y = Map StrToNat (Words x)
  w = Index 1 y
  h = Index 0 y
} PutString (Unlines (Replicate h (Replicate w '#'))))

import Pre.IO

PutLine ({
  fs = Fix (\f. Cons 1 (Cons 1 (Zip Add f (Tail f))))
  f40 = Index 40 fs
} NatToStr f40)

import Pre.IO

Bind GetLine (\x.{
  xs = Words x
  s = Index 0 xs
  n = StrToNat (Index 1 xs)
  c = Index 0 (Index 2 xs)
  m = StrToNat (Index 3 xs)
  s' = {
    ss = Split (Pred n) s
  } Append (Fst ss) (Cons c (Snd ss))
  s'' = {
    ss = Split (Pred m) s'
  } Append (Fst ss) (Tail (Snd ss))
} PutLine s'')

lang: PSL
creator: @P9Silica

https://github.com/Silica/PSL
ゲームから呼び出す為に作った組み込みスクリプト言語
Cで書かれたLuaと比べると値の受け渡しや相互の関数呼び出しが非常に簡単に行えます．

言語としては何となくオブジェクト指向っぽいものを持つ動的型付け言語です．

各解説
・hello world
関数呼び出しはC言語同様()でも可能なのですが関数適用演算子`(バッククオート)も存在しています．

・square
文字列に対して乗算 * 演算子を適用すると文字列を繰り返します．
0の時も元の文字列は残るので0が入力された時も要件に入るなら普通にループを書きます．

・fibonacci number
愚直な再帰で書くとそれなりに遅いです．
ループを回して多重代入を利用して簡潔に記述しています．
値の交換も a, b = b, a; で可能です．

・Editor!
なんで1番目からなんですか．
文字列に対して / や % 演算すると切り取ります．
str / n で前からn文字を残す
str % n で前からn文字を削って後ろを残す
使っていませんが - は後ろからn文字削ります

hello world

square

fibonacci number

Editor!

print`"hello world";

int w = strlib.gets();
int h = strlib.gets();
square(w, h);

square(w, h)
{
	line = "#" * w + "\n";
	print ` line * h;
}

fib(n)
{
	a, b = 0, 1;
	while (n--)
	{
		a, b = b, a + b;
	}
	return a;
}

print`fib`40;

s = strlib.gets();
a = strlib.split(s, " ");
string text = a[0];
int ins = a[1];
string word = a[2];
int del = a[3];

ins -= 1;	// なんで1番目から…
del -= 1;

text = (text / ins) + word + (text % ins);
text = (text / del) + (text % (del+1));
print(text);

lang: T言語
creator: @h_sakurai

T言語 [1] はPrologで実装がたった200行の型推論付き関数型言語です。T言語はFlops 2016のTIPER [2] に大きな影響を受けています。
型理論の論文で用いられる推論規則は論理型言語なのでPrologを用い論文の記法に出来るだけ近付けて実装しました。
[1] http://github.com/hsk/t/ [2] http://slides.com/kyagrd/tiper-flops2016

## hello world

通常のML系の言語は括弧を書かずに引数を渡す事が出来ます。
C言語系統の言語ではadd(1,2)と書く所をOCaml等ではadd 1 2と記述出来ます。
しかし、Prologでは残念ながらこのように書く事は出来ません。そこで、add $ 1 $ 2のように記述します。

Hello worldのプログラム:

println_string $ "hello world!"

は、println_string関数に"hello world!"文字列を引き渡して関数適用しています。

## square

T言語ではリストデータとしてargvにコマンドライン引数が渡されてきます。
パターンマッチにより引数を取得します。
T言語のパターンマッチはCoPLのEvalML4相当の単純なパターンマッチなので複雑な事は出来ないためこのような実装になっています。
write_sharp関数が#を1行出力します。
write_sharp_line関数が複数行出力します。
int_of_stringは文字列からint値に変換する関数です。

## fibonacci number

fibは単純に再帰的に呼び出しています。高速化する気はないのでfib(40)だといつ帰ってくるか分からない程時間がかかります。

## Editor!

squareのようなやり方で引数を複数受け取るのはさすがに大変です。
そこで引数受け取り関数nthを作成しました。
nth関数はListのn番目の値を取得します。
insert関数で指定箇所に文字を加えます。
remove関数で指定箇所の文字を削除します。
あとはそれぞれの関数を呼び出すだけです。

hello world

square

fibonacci number

Editor!

println_string $ "hello world!"

match(argv | []->println_string $ "input error"
| x::y->
  match(y | []->println_string $ "input error"
  | h::z->
    match(z | []->println_string $ "input error"
    | w::zz->
      letrec write_sharp = (w ->
        if w < 1 then let x = "\n" in print_string $ x else
        let t = print_string $ "#" in
        write_sharp $ (w - 1)
      ) in
      letrec write_sharp_line = (h -> w ->
        if h < 1 then "" else
        let t = write_sharp $ w in
        write_sharp_line $ (h - 1) $ w
      ) in
      write_sharp_line $ (int_of_string $ h) $ (int_of_string $ w)
    )
  )
)

letrec fib=(x ->
  if x < 1 then 0
  else if x < 2 then 1
  else (fib $ (x - 2))+(fib $(x-1))
) in
println_int $ (fib $ 40)

letrec nth=(s -> n -> 
  match(s
    | []->""
  	| x::xs->if n < 1 then x else nth $ xs $ (n-1)
  )
) in
let s = nth $ argv $ 1 in
let n = nth $ argv $ 2 in
let e = nth $ argv $ 3 in
let m = nth $ argv $ 4 in
letrec insert=(s -> n -> v ->
  if n<2 then v::s else
    match(s
    | [] -> v::s
    | x::xs -> x::insert $ xs $ (n-1) $ v
    )
) in
letrec remove=(s -> n ->
  match(s
  | [] -> []
  | x::xs -> 
    if n<2 then xs else x::remove $ xs $ (n-1)
  )
) in
let e = match(e | []->0 | x::xs->x) in
println_string $ (remove $ (insert $ s $ (int_of_string $ n) $ e) $ 3)

lang: Shiranui
creator: @Tomoki_Imai

Shiranui はテストと統合したライブプログラミング環境です．
ライブプログラミング環境とは，書いたプログラムのフィードバックがすぐに得られるような開発環境のことです．

コードだけではわかりづらいので，以下に今回の問題を解いてみた動画があります．
- https://www.youtube.com/watch?v=BDWqy6aPX2Q
- http://www.nicovideo.jp/watch/sm28515042

github は以下
https://github.com/tomoki/Shiranui

論文も一応あります． (abstract ですが)
- http://dl.acm.org/citation.cfm?id=2817268
- http://dl.acm.org/citation.cfm?id=2814193

1. hello world
#- からはじまる行はテストコードです．
\(){} は関数オブジェクトです．

2. square
repは，文字列を複数回連結するプログラムです．
内部は簡単な再帰です．

それを使えばsquareも容易に記述できます．
ここでのポイントは関数の中の関数もテストすることができることです．
Shiranui はクロージャを表現する特別な記法があります．
例えば， <|a=$(sq->a,wall->"###")s|> の意味は，
sqが'a'，wallが"###"となっている環境でのラムダ式sから生成される関数オブジェクトです．
(ただし，'a' は自己参照)

3. fibonacci number
残念ながら，fib(40)は Shiranui ではスタックオーバーフローします．
ここでは，メモ化再帰を使うことでそれを回避しています．

特徴は，[0 .. 3) という記法で，これは [0, 1, 2] となります．
数学の半開区間をそのまま表現できます．

4. Editor!
ここでは ref というあたらしいものがあります．
ref は OCaml からもってきたもので，あたらしい箱を作ります．

Shiranui の特徴のおかげで，たくさんのユニットテストを作成することができました．

hello world

square

fibonacci number

Editor!

#- hello_world() -> "hello world";
let hello_world = \(){
    return "hello world";
};

#- rep("#", 0) -> "";
#- rep("#", 3) -> "###";

let rep = \(s, n){
    if n = 0 {
        return "";
    } else {
        return s + rep(s, n-1);
    }
};

#- square(2, 3) -> "###\n###";
#- <|$(wall->"###")s|>(1) -> "###";
#- <|a=$(sq->a,wall->"###")s|>(2) -> "###\n###";
let square = \(h, w) {
    let wall = rep("#", w);
    let sq = \s(h){
        if h = 1 {
            return wall;
        } else {
            return wall + "\n" + sq(h-1);
        }
    };
    return sq(h);
};

let len = system_call("length");
let set = system_call("set");
let get = system_call("get");
#- fib(0) -> 1;
#- fib(1) -> 1;
#- fib(2) -> 2;
#- fib(3) -> 3;
#- fib(4) -> 5;
#- fib(5) -> 8;
#+ fib(40) -> 165580141;

let fib = \(n){
    let memo = [0 .. n];
    for i in [0 .. len(memo)){
        set(memo, i, -1);
    }
    let fib_i = \(n){
        if n = 0 or n = 1 {
            return 1;
        } else {
            let u = get(memo, n);
            if u /= -1 {
                return u;
            } else {
                let s = fib_i(n-1) + fib_i(n-2);
                set(memo, n, s);
                return s;
            }
        }
    };
    return fib_i(n);
};

let len = system_call("length");
let set = system_call("set");
let get = system_call("get");

#- tail("abc") -> "bc";
let tail = \(s){
    let ret = ref "";
    for i in [1 .. len(s)){
        ret <- !ret + get(s, i);
    }
    return !ret;
};

#- insert("hello", 100, "e") -> "hello";
#- insert("hollo", 4, "e") -> "holelo";
#- insert("hollo", 2, "e") -> "heollo";
let insert = \(s, n, c){
    if s = ""{
        return s;
    }
    if n = 1 {
        return c + s;
    } else {
        return get(s, 0) + insert(tail(s), n-1, c);
    }
};


#- remove("hello", 1000) -> "hello";
#- remove("hello", 1) -> "ello";
#- remove("heollo", 3) -> "hello";
let remove = \(s, m){
    if s = ""{
        return s;
    }
    if m = 1 {
        return tail(s);
    } else {
        return get(s, 0) + remove(tail(s), m-1);
    }
};

#- editor("hollo", 2, "e", 3) -> "hello";
let editor = \(s, n, c, m){
    return remove(insert(s, n, c), m);
};

lang: XASH
creator: @long_long_float

Github: https://github.com/long-long-float/xash
Rubygems: https://rubygems.org/gems/xash

XASH(eXecutable hASH)はYamlなどのkey-valueなデータ形式で記述できるプログラミング言語です。詳しくは https://github.com/long-long-float/xash/wiki/Document をご覧ください。

この言語はRubyで書かれているので動かしたい方は

gem install xash

でインストールすれば、

xash FILE

で実行できます。

* hello world

XASHは評価した値をそのまま出力するので単に"hello world"と書くだけで出力されます(ずるい?)

* square

XASHではforは式で評価した値をまとめるので(map関数みたいなもの)、HとWだけforを回してその中で#を返すだけで欲しい出力が得られます。あとはこれをjoinすれば四角形が出力されます。

あと、XASHでは入力が出来ないのでHとWを直接書いています。

* fibonacci number

expr: [...] で計算式を評価できます。見難いですね。また、key-valueな変数が使えないのでメモ化なんて出来ませんでした。

* Editor!

XASHでは配列を直接書き換える関数は用意されていないので、head, tail, consで関数型言語っぽく書いてみました(実際Haskellで下書きしてからこっちに移植した)。

hello world

square

fibonacci number

Editor!

- ["hello world"]

- def: [igeta,
  do: [ ar: [H, W],
    join: [
      for: [1..$W,
        do: [ ar: [y],
          join: [for: [1..$H, do: [ ar: [x], '#' ]], '']
        ]
      ],
      "\n"
    ]
  ]
]

# 入力なんてなかった
- igeta: [10, 20]

- def: [fib,
  do: [ ar: [n],
    case: [
      [$n, "<=", 1], do: [$n],
      do: [
        expr: [
          fib: [expr: [$n, -, 2]],
          "+",
          fib: [expr: [$n, -, 1]]
        ]
      ]
    ]
  ]
]

- [ fib: [10] ]

- def: [edit,
  do: [ ar: [S, n, c, m],
    def: [ ins,
      do: [ ar: [str, n, c, i],
        assign: [s, head: [$str]],
        assign: [ss, tail: [$str]],
        case: [
          [$i, ==, $n], do: [cons: [$c, $str]],
          do: [cons: [$s, ins: [$ss, $n, $c, expr: [$i, +, 1]]]]
        ]
      ]
    ],
    def: [ del,
      do: [ ar: [str, m, i],
        assign: [s, head: [$str]],
        assign: [ss, tail: [$str]],
        case: [
          [$i, ==, $m], do: [$ss],
          do: [cons: [$s, del: [$ss, $m, expr: [$i, +, 1]]]]
        ]
      ]
    ],
    del: [ ins: [$S, $n, $c, 1], $m, 1]
  ]
]

- def: [collection,
  do: [ ar: [val], for: [$val, do: [ar: [e], $e ]]]
]

- [ join: [ edit: [collection: [hollo], 2, e, 3], ''] ]

lang: Twintail(仮)
creator: @GnicoGplus

Twintailは”まるちぱらだいむ”な言語で，入力コードをILに変換します．そのため，コンパイル・実行には，.Net Frameworkが必要です．
各問題には，ILに出力した後は，こんな感じになるだろうっていうコードを載せてます．まだ完成していないので，理想です．

"#set non-obejected"により，手続き型言語風の書き方ができます．

*言語概要*
マクロが定義できたり，関数型プログラミングもどきができたりします．そんだけです．
目標は，Nemerleのマクロ機能をもう少し使いやすくしようって言う感じです．

*Hello World*
System.Console.WriteLine(System.String)を使って出力しています．

*Square*
ReadFormatは，一見関数に見えますが，マクロです．IL出力後は"ReadFormat"というのが一字一句も無いのがわかるでしょうか．
ReadFormatマクロ(完全名：Twintail.Console.ReadFormat(<Immutable>System.String) : TwintailExp)は，コンパイル時に，渡された値によって，一つの匿名的な静的関数をその使われているクラス上に展開します．その中で，色々します．コンパイル時に決まる文字列でないと受け付けないので注意してください．また，"string string"といった事はできません．

"loop"も標準構文の様に見えますが，これもマクロです．コンパイル時に，for文に変換されます．このように，新たなSyntaxも定義できちゃいます．ほぼ完全にNemerleのパク(ｹﾞﾌﾝｹﾞﾌﾝ

catch { _ => ...}っていうのがあるように，関数型の皮被ってますが，不純なので気をつけてください．

*Fibonacci Number*
[Memorise]はマクロです．|>はパイプライン演算子です(F#からのパクリです)

def ほにゃらら(引数)　で匿名関数が作られます．型推論できるようにコンパイラをつくるつもりなので，型名などは書いてません．

*Editor!*
Squareと基本的に同じです．

hello world

square

fibonacci number

Editor!

#set non-objected

System.Console.WriteLine("hello world")

↓ IL化した後のコードをC#に翻訳したもの
namespace <FileName> {
  public class Main {
    public static void main(string[] srgs) {
      System.Console.WriteLine("hello world");
    }
  }
}

#set non-objected

Import System;
Import macro Twintail.Core;
Import macro Twintail.Console;

try {
  def input = ReadFormat("uint uint");
  loop(input.Item1) 
    WriteLine(new string('#', input.Item2))
} catch {
  | _ => WriteLine("INPUT Format is invalid")
}

↓ IL化した後のコードをC#に翻訳したもの


namespace <FileName> {
  public class Main {
    public static void main(string[] srgs) {
      try {
        System.Tuple<uint, uint>input = TWINTAIL_LAMBDA_MAIN01();
        for(int n = 0; n < input.Item1; n++)
          WriteLine(new string('#', input.Item2));
      } catch(Exception _e) {
        System.Console.WriteLine("INPUT Format is invalid");
      }
    }

    private static System.Tuple<uint, uint> TWINTAIL_LAMBDA_MAIN01() {
      string input = System.Console.ReadLine();
      string[] cutted = input.Split(' ');
      return System.Tuple.Create(uint.Parse(cutted[0]), uint.Parse(cutted[1]));
    }
  }
}

#set non-objected;
Import System;
Import macro Twintail.Core;

[Memorise]
def fib(n) {
  | 1 | 2 => 1;
  | _ => fib(n - 1) + fib(n - 2);
}

fib(40) |> Console.WriteLine(_)

↓ IL化した後のコードをC#に翻訳したもの
namespace <FileName> {
  public class Main {
    public static void main(string[] srgs) {
      var _tawintail_memo_lambda = new TWINTAIL_MEMORISED_CLASS_MAIN01();
      Console.WriteLine(_twintail_memo_lambda.TWINTAIL_LAMBDA_MAIN01(40));
    }
    private class TWINTAIL_MEMORISED_CLASS_MAIN01 {
      var memo = new System.Collections.Generic.Dictionary<int, int>();
      private static int TWINTAIL_LAMBDA_MAIN01(int n) {
         switch(n) {
           case 1: case 2: return 0;
           default: 
             int e1;
             if(memo.ContainsKey(n - 1)) 
               e1 = memo[n - 1];
             else {
               e1 = TWINTAIL_LAMBDA_MAIN01(n - 1);
               memo.Add(n - 1, e1);
             }
             int e2;
             if(memo.ContainsKey(n - 2)) 
               e2 = memo[n - 2];
             else {
               e2 = TWINTAIL_LAMBDA_MAIN01(n - 2);
               memo.Add(n - 2, e2);
             }
             return e1 + e2;
      }
    }
  }
}

#set non-objected

Import System;
Import macro Twintail.Console;

try {
  def input = ReadFormat("string int char int");
  input.Item1.Insert(input.Item2, input.Item3).Remove(input.Item4, 1) |> WriteLine(_);
} catch {
  | _ => WriteLine("INPUT Format is invalid")
}

↓ IL化した後のコードをC#に翻訳したもの


namespace <FileName> {
  public class Main {
    public static void main(string[] srgs) {
      try {
        System.Tuple<string, int, char, int>input = TWINTAIL_LAMBDA_MAIN01();
        System.Console.WriteLine( input.Item1.Insert(input.Item2, input.Item3).Remove(input.Item4, 1));
      } catch(Exception _e) {
        System.Console.WriteLine("INPUT Format is invalid");
      }
    }

    private static System.Tuple<uint, uint> TWINTAIL_LAMBDA_MAIN01() {
      string input = System.Console.ReadLine();
      string[] cutted = input.Split(' ');
      int cache = 0;
      System.Text.StringBuilder FirstReturner = new Systen.Text.StringBuilder();
      int n;
      for(n = 0; !int.TryParse(cutted[n], out cache); ++n) {
        FirstReturner.Append(cutted[n]);
      }
      return System.Tuple.Create(FirstReturner.ToString(), int.Parse(cutted[n + 1]), (char)(cutted[n + 2]), int.Parse(cutted[n + 3]) );
    }
  }
}

lang: hexe
creator: @hum_op

hexe言語にはメイン関数はなく, いきなりコードを書くことができます.

hexe言語では, 1次元配列をサポートしています.
行末はセミコロンで表すことができますが, これは省略することができます. ただ, fibonacci number問題での3行目のように1行に複数の命令を書いた場合明示的にセミコロンを書く必要が有ります.
関数や変数の宣言は, set を使用し, 変数には$をつけそれ以外は関数として扱います.
変数への値の割り当ては << を使用します.

hexe言語では, whileやforのような繰り返し処理をサポートしていません. そのため, init関数のようにして繰り返し処理を行います.

四則演算子と他の演算子
+ 和
- 差
* 積
/ 商

% 剰余
^ べき乗

比較演算子
hexe言語では, 以下の比較演算子を使用することができます.
= 左辺と右辺は等しい
<> 左辺と右辺は等しくない
< 左辺は右辺より小さい
<= 左辺は右辺以下
> 左辺は右辺より大きい
>= 左辺は右辺以上

★hello world問題
printというビルトイン関数で文字列を表示します.

print 文字列

★square問題
getvというビルトイン関数で数値を入力します.getvはget valueの意です.
そして, 再帰関数を用いてループをし井桁を入力された幅と高さ通りに表示します.

★fibonacci number問題
メモ化再帰によってフィボナッチ数を求めています.

★Editor!問題
言語仕様により実装不可(対応させたい)

hello world

square

fibonacci number

Editor!

print "hello world"

// 与えられた高さ(H)と幅(W)の四角形を表示する
set showSquare($H, $W){
  if $H > 0 {
    putIGETA($W)
    showSquare($H-1, $W)
  }
}

// n個井桁(#)を表示し改行する
set putIGETA($n){
  if $n > 0 {
    print "#"
    putIGETA($n-1)
  }
  print "\n"
}

set $h, $w  // 変数の宣言
getv $h     // 高さを入力
getv $w     // 幅を入力

// 四角形を表示
showSquare($h , $w)

set $memo[41]
init(40)
$memo[1] << 1; $memo[2] << 1;

print fib(40)

set init($n){
    if $n >= 0 {
        $memo[$n] << 0
        init($n-1)
    }
}

set fib($n){
    if $n = 0 {
        return 0;
    }
    if $memo[$n] <> 0 {
        return $memo[$n]
    }
    $memo[$n] << fib($n-1) + fib($n-2)
    return $memo[$n]
}

lang: Logical
creator: @Twi_Stamp

http://pitto.exout.net/Logical/explain.html

hello world

square

fibonacci number

Editor!

//[100]は0
//[101]は1
101+
//[102]は-1
102~
//[113]は13(改行用)
113+<+<<+
//[115]は15(キーコードから数値を取得するため)
115+<+<+<+
//[132]は32(スペース)
132+<<<<<
//[135]は35(#)
135+<<<<+<+
//[148]は48(0)
148+<+<<<<

248=148~
200=101
[200
  201=248^200
  202=248<&200<
  248=201^202
  200=201<&202<
]

//[248] = -48

//0と1が縦と横
//[0]=入力されたキーコード-48
,
//0=65535
//302=248
//[302
  //300=0^302
  //301=0<&302<
  //0=300^301
  //302=300<&301<
//]
0=65535&115
*0.132

,
//1=65535
//302=248
//[302
  //300=1^302
  //301=1<&302<
  //1=300^301
  //302=300<&301<
//]
1=65535&115
*1.113

400=0
[400
  500=1
  [500
    //「#」を表示
    .135
    //[500]--
    602=102
    [602
      600=500^602
      601=500<&602<
      500=600^601
      602=600<&601<
    ]
  ]
  602=102
  [602
    600=400^602
    601=400<&602<
    400=600^601
    602=600<&601<
  ]
  .113
]

//[100]は0
//[101]は1
101+
//[102]は-1
102~
//[113]は13(改行用)
113+<+<<+
//[132]は32(スペース)
132+<<<<<
//[148]は48(0)
148+<+<<<<

//[0]はfib(n)のn=40
0+<<+<<<

//[1],[2]の数字を交互に足していく
//[1]=0, [2]=1
2+

//[3]はカウンタ、[0]と同じ数字になるまでループ
//3=1
3+

//[4]が[3]と[0]の比較結果
4+

[4
	//[1]+=[2]
	202=2
	[202
		200=1^202
		201=1<&202<
		1=200^201
		202=200<&201<
	]

	//[3]++
	302=101
	[302
		300=3^302
		301=3<&302<
		3=300^301
		302=300<&301<
	]

*1.113

	//カウンタとnが等しければ次のブロックは実行されない
	4=3^0
	5=1

	[4
		//[2]+=[1]
		402=1
		[402
			400=2^402
			401=2<&402<
			2=400^401
			402=400<&401<
		]

		//[3]++
		502=101
		[502
			500=3^502
			501=3<&502<
			3=500^501
			502=500<&501<
		]

		4=100
		5=2
*2.113
	]
	4=3^0
]