The direction of the road is sometimes slightly different between neighboring towns. I painted the streets in different colors depending on the direction to make it easier to see.

I’ve done it in Hokkaido, Tokyo, Kyoto, New York, etc.

(This article is a machine translation of https://dailyportalz.jp/kiji/douro-hougaku-machi-no-dekikata)

Tokyo

If you zoom in, this is what it looks like.

The road is painted according to its direction.

The yellow area on the right is Koto-ku. The colorful area in the center is Ginza and Nihonbashi. The colors make it easy to see that the direction of the streets is slightly different in each city.

I wondered if I could do this kind of thing, and when I tried it, I was able to do it, and the results were interesting, so I decided to try it out in various places.

(The map in this article is based on data from OpenStreetMap. More details at the end)

The first thing that impresses me about Tokyo is the fact that the roads in Koto-ku are oriented almost exactly north-south or east-west. In this map, such roads are painted in yellow, so Koto-ku is yellow.

This seems to be because a man-made river called the Onagi River was first drawn east to west in the Edo period. This is because of the water transportation to Chiba. The fact that the road is slightly tilted to the west instead of true north, is probably due to the gap between the compass north (magnetic north) and true north.

It’s also nice that the grating is completely different in the east and west of the castle. It seems to be related to the fact that the east side is low and flat, while the west side is mountainous and has many ups and downs.

Sapporo

As for Sapporo, look at an enlarged version of the central area first.

The road tilts to the west around the Sapporo Station. On the other hand, the road in the area called “Yamahana” in the lower part of the picture is yellow and faces true north. The angle of the road is slightly changed when you walk on the road, which is located behind Susukino.

In a large area, the direction of the road is completely different in each city.

The Sousei River, a man-made river marked in light blue, follows the slope of Sapporo’s fan-shaped area. And the roads in the city center are built to face the Sosei River. In other words, the direction of the grid is determined by which way the ground under our feet is inclined. I think the situation is similar to Kotoni’s.

However, I don’t know why only Yamahana and Hassamu are exactly aligned to the north, south, east and west. They are slightly off to the west and may have been aligned to the north of the compass.

Yokohama

I want to take a quick look at it. Next is Yokohama.

In a large area, the city of Yokohama is chaotic. That is to say, there is hardly any grid of streets. But only the center of the city is grid-like.

It looks nice. The grid in the middle is a lowland area with several rivers running through it. The chaos above and below is the high ground. It may be said that the grid-like road is easy to be formed in the lowland.

If you expand it further, it looks like this. The baseball field is pretty in the middle, with a rainbow of colors. The hue is rotated according to the angle of the road, so it looks like this.

The one on the right of the center is Chinatown, which is partly yellow. If you walk here, you can see that the direction of the street is different only here. This discrepancy seems to originate from the former rice field.

Kyoto

Isn’t Kyoto kind of cool? I might want one of these posters.

Most of the roads in Kyoto are yellow. That is to say, there are many roads along the true north or true east. However, if we zoom in, we can see that not all the roads are like that.

The upper part of the image is green or purple in color, which is the road along the river upstream of the Kamo River. And as you approach the mountain on the right, you can see that the grid is broken. Does this mean that the terrain does not allow a grid? (I thought so, but not in San Francisco.)

It is interesting to note that Nijo Castle is slightly tilted to the east on the left side of the map. This is because the north of the compass tilts slightly to the east in Kyoto at that time.

Folk direction of Hateruma Island, Okinawa

In Hateruma Island, a remote island in Okinawa, there are two different angles of the road. The first one is yellow, reflecting recently created fields, which are perfectly aligned to the north, south, east and west.

The center of the island is purple, and the grid is slightly rotated clockwise. Let’s zoom in a bit.

This purple color corresponds to the house as well.

In this area, strong winds blow seasonally along the direction from southwest to northeast, and the village is built perpendicular to the direction of the wind. In order to prevent the wind from blowing, villages are built perpendicular to the direction of the wind.

The direction in this area is based on the direction of the monsoon winds. This is called “folk direction”.

New York

Finally, let’s take New York City. Everywhere here is a large grid, and the direction of the grid varies from place to place. It’s like Sapporo.

Where does this difference in orientation between the different districts come from? I’m not sure. Is it the topography? Or maybe it’s along some of the main lines they first pulled. Please let me know if you know about this.

I enlarged the area around Central Park. The green line running vertically through the center is Broadway. To make it stand out, the hue is slightly changed.

Broadway was a street before this grate was built. The intersection with the lattice becomes a sharp angle, and sometimes a building with a very sharp angle is built there. The Flatiron Building seems to be the most famous such building.

About Map

The map in this article was drawn from a program by anvaka that draws roads based on data from OpenStreetMap with changes to color the roads.

The original program:
https://github.com/anvaka/city-roads

A modified version of the program:
https://github.com/mitsuchi/city-roads

このところ、趣味でプログラミング言語を作っています。

どんな言語を作っているか

静的な型付けの関数型プログラミング言語で、見ためはこんな感じです。

# hello, world!
puts "hello, world!"

# 1 * 2 * .. * n を計算する関数
fun factorial : Int -> Int = {
    1 -> 1
    n -> n * factorial (n-1)
}
factorial 5   #=> 120

型について理解したいという気持ちがあったので、型検査や多相型など、型に関する機能を少しづつ取り入れて作っています。

プログラミング言語 Mud
http://mud.tiny-app.net/

なぜ作っているか

純粋に楽しみとしてです。世の中にまともな言語がたくさんあるのに、今さらおもちゃみたいなものを新しく作る意味ないよねとも思いますが、どんな分野でも自分だけのちょっとしたものを自作するのはやっぱり楽しいものです。

あと既存の言語についての勉強にもなります。

どんな言語機能が欲しかったか

最初の動機となったのは、「関数型の言語で、関数適用の関数名と第一引数の順番を “.” でひっくり返せばオブジェクト指向っぽく見えるんじゃないか」という思いつきでした。

関数型の言語では、以下のような式を書くことになるケースがあると思います。

reverse (uniq (sort [2,1,4,1]))
#=> [4,2,1]

意味としては、 [2,1,4,1] というリストをソートして、重複を取り除いて、逆順にするということになります。

ですが、ふつうに左からコードを読むと、「ひっくり返す。なにを？　重複を取り除いたものを。なにから？・・」となって読みづらいことになります。意味をつかむためには式を右から左に、逆順に読まなければいけません

それがめんどくさいよねということで、既存の言語、たとえば Elixir だと |> 演算子があって、関数呼び出しの引数と関数名の位置をひっくり返すことができます。つまり

sort [2,1,4,1]

を

[2,1,4,1] |> sort

と書くことができる。なので、これを繰り返すと元の式はこうなります。

[2,1,4,1] |> sort |> uniq |> reverse

「[2,1,4,1] というリストをソートして、重複を取り除いて、ひっくり返す」という素直な語順どおりになりました。

でも思ったのです。これ  |> じゃなくて “.” なら普通にオブジェクト指向っぽい見た目になるじゃんと。つまりこういうことです。

[2,1,4,1].sort.uniq.reverse

ふつうに Ruby で動きそうな見た目になりました（実際動きます）。

なので、こんなふうに、関数型の言語なのに見ためはオブジェクト指向っぽく書ける言語を作ってみようと思ったのがきっかけでした。

（あとから知りましたが、そういうアイデアの言語はすでにいっぱいあるようです。Nim や、あるいは Ruby のまつもとゆきひろさんの Streem がそうです。でもそういう人たちと同じアイデアを思いつけたのは嬉しいです。 ）

シンプルな関数定義

Haskell の関数定義の構文がとてもシンプルで、好きです。たとえば 1 * 2 * 3 * .. * n を関数を計算する関数 factorial は、こう書けます。

factorial :: Int -> Int
factorial 1 = 1
factorial n = n * factorial (n-1)

そして Elixir の匿名関数の構文もまたシンプルでかっこいいと思います。

factorial = fn
   1 -> 1
   n -> n * factorial (n-1)
end

なので、両方を合わせたこんな感じの関数定義の構文が使えるようにしました。

fun factorial : Int -> Int = {
   1 -> 1
   n -> n * factorial (n-1)
}

関数の値への適用（呼び出し）は Haskell ふうに

factorial 5
#=> 120

と、引数をカッコでくくらずに並べます。

多重ディスパッチと自由な演算子オーバーロード

もうひとつ欲しかったのが、自由な演算子オーバーロードでした。たとえば Ruby のように、 + のような演算子をいろいろな意味で気軽に定義したい。

1 + 2 は 3
"a" + "b" は "ab"

のように。

そこで、多重ディスパッチという仕組みを取り入れました。同じ関数名（演算子名）でも、引数の型が一つでも違えば違う関数として定義することができるというものです。

# 整数に1を足したものを返す
fun incr : Int -> Int = {
   x -> x + 1
}
# 数の英語表現に1を足したものを返す
fun incr : String -> String = {
  'zero' -> 'one'
  'one'  -> 'two'
  'two'  -> 'three'
}

# 同じ関数名でも引数の型によって異なる関数が呼び出される
incr 2       #=> 3
incr 'two'   #=> 'three'

# . 演算子を使えばオブジェクト指向的なポリモーフィズムに見える
2.incr      #=> 3
'two".incr  #=> 'three'

上は、作っている言語での実際に動作するサンプルです。同じ関数名でも引数の型によって動作がちゃんと違っています。

この言語では、演算子も関数として定義されるようにしています。なので、多重ディスパッチの仕組みを使うことによって、同じ演算子を次のようにいろんな意味に使い分けることができます。

# 整数と整数の掛け算
2 * 3      
#=> 6

# 文字列と整数の掛け算
"abc" * 3       
#=> "abcabcabc"

# リストと整数の掛け算
[1,2,3] * 3       
#=> [3,6,9]

# リストとリストの内積
[1,2,3] * [1,2,3]       
#=> 14 (1*1 + 2*2 + 3*3)

# 関数合成
(incr * factorial) 5
#=> 121 (nの階乗に1を足す、という関数にn=5を適用する)

多重ディスパッチ（Multiple Dispatch ）の仕組みはぼくにとってはかなり面白かったので、その頭文字を取って言語名を Mud としました。

なお、多重ディスパッチを機能として前面に出している言語としては、最近では Julia があると思います。

どうやって作っているか

実装言語は Haskell です。

megaparsec というライブラリで字句解析、構文解析をして式を抽象構文木に変換しています。その後に型検査をして、問題がなければ、抽象構文木のまま評価しています。つまり、コンパイラーではなくてインタープリターで、その中でも最も簡単な（速度が出ない）やり方です。 Tree Walking Interpreter というそうです。

ソース
https://github.com/mitsuchi/mud/

最初は42みたいな数字だけを認識できるものを作り、次は足し算だけができるものをつくり、つぎは変数が使えるようにする、というふうに機能を足しながら作りました。これだと、小さいながらどの段階でも言語としてちゃんと動くので、作っていて楽しいです。このあたりは次の本を参考にしました。

低レイヤを知りたい人のためのCコンパイラ作成入門（Rui Ueyamaさん）https://www.sigbus.info/compilerbook/

どこらへんが楽しいか

言語を作るたのしさは、好きな構文や機能を自分でデザインできちゃうところだと思います。空想地図を書いたりする人たちの楽しみと近いところがあるかもしれない。

こういう構文があったらなーとか、既存の言語のここがこうなっていて欲しいなーというときに、それを実現したものが（苦労するけど）作れて、なおかつ動くというのは嬉しい。

それから、どこまでもいじれてしまうというところも趣味に向いてます。たとえば言語の核の機能をもっと足そうとか、ライブラリーを足そうとか、エラー処理をまともにしようとか、いじろうと思えばずっといじれます。

この言語も、整数と変数が使えて関数が定義できるところまでできたらいいなと思っていました。が、いざ動くようになってくると、やっぱり浮動小数点数も使いたい、文字列も使いたい、高階関数も、多相性も、といろいろと欲がでて少しずつ大きくなっています。

つぎはコンパイラー型にしてみたいです。LLVMのIRを出力するようにできたら楽しいだろうなと思います。

動作デモ

ブラウザーから、この言語のいろんなサンプルコードを編集して動かせるページを作りました。よければ遊んでみてください。

Mud プレイグラウンド
http://mud.tiny-app.net/playground/