最速のEchoサーバーを目指して、LinuxKernelモジュールを作っていく part3
はじめに
前回まで
rabbitfoot141.hatenablog.com
rabbitfoot141.hatenablog.com
この二回でカーネルモジュールで標準出力や、カーネルスレッドを動かすところまでやった。
今回はこれをTCPサーバー化するのを目標にやっていく。
ネットワーク周り
さくっと実装したいが、カーネルモジュールでのネットワーク周りがわからないので
そこあたりから色々調べていく。
ソケット周り
これが使えないとネットワーク通信ができないのでこれがどういう仕様で実装されているか調べてみる。
見つかった。
http://elixir.free-electrons.com/linux/v3.4/source/include/linux/net.h#L138
これは
#include <linux/net.h>
というヘッダーにあることがわかった。
これの138行目にsocketという名前の構造体があり。
こいつがBSDのソケットとして使えるようなので使うことにする。
/** * struct socket - general BSD socket * @state: socket state (%SS_CONNECTED, etc) * @type: socket type (%SOCK_STREAM, etc) * @flags: socket flags (%SOCK_ASYNC_NOSPACE, etc) * @ops: protocol specific socket operations * @file: File back pointer for gc * @sk: internal networking protocol agnostic socket representation * @wq: wait queue for several uses */ struct socket { socket_state state; kmemcheck_bitfield_begin(type); short type; kmemcheck_bitfield_end(type); unsigned long flags; struct socket_wq __rcu *wq; struct file *file; struct sock *sk; const struct proto_ops *ops; };
色々なコードや、文献を漁っているとこの中でも次に重要になるのが
const struct proto_ops *ops;
という構造体。
この構造体の実装は次のようになっている。
struct proto_ops { int family; struct module *owner; int (*release) (struct socket *sock); int (*bind) (struct socket *sock, struct sockaddr *myaddr, int sockaddr_len); int (*connect) (struct socket *sock, struct sockaddr *vaddr, int sockaddr_len, int flags); int (*socketpair)(struct socket *sock1, struct socket *sock2); int (*accept) (struct socket *sock, struct socket *newsock, int flags); int (*getname) (struct socket *sock, struct sockaddr *addr, int *sockaddr_len, int peer); unsigned int (*poll) (struct file *file, struct socket *sock, struct poll_table_struct *wait); int (*ioctl) (struct socket *sock, unsigned int cmd, unsigned long arg); #ifdef CONFIG_COMPAT int (*compat_ioctl) (struct socket *sock, unsigned int cmd, unsigned long arg); #endif int (*listen) (struct socket *sock, int len); int (*shutdown) (struct socket *sock, int flags); int (*setsockopt)(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen); int (*getsockopt)(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen); #ifdef CONFIG_COMPAT int (*compat_setsockopt)(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen); int (*compat_getsockopt)(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen); #endif int (*sendmsg) (struct kiocb *iocb, struct socket *sock, struct msghdr *m, size_t total_len); int (*recvmsg) (struct kiocb *iocb, struct socket *sock, struct msghdr *m, size_t total_len, int flags); int (*mmap) (struct file *file, struct socket *sock, struct vm_area_struct * vma); ssize_t (*sendpage) (struct socket *sock, struct page *page, int offset, size_t size, int flags); ssize_t (*splice_read)(struct socket *sock, loff_t *ppos, struct pipe_inode_info *pipe, size_t len, unsigned int flags); void (*set_peek_off)(struct sock *sk, int val); };
bind,listen,acceptなどなど、どこかで見たことのあるような単語が並んでいる。
実際にtcpサーバを構築するときは、これらの関数に必要な情報を渡して呼び出す必要がある。
なんやかんや、C言語でネットワークプログラミングをする時と同じ様なあれこれはあるので
それと似たような感じでコードを書けそう。
この後で実装するコードは、カーネルスレッドを多用するので
kernel_lock関数を使った方がいいとかはまた別途考える必要がある。
文字列周り
文字列周りの扱いはどうしようかと調べていたら、linux/socket.hにちょうどいい構造体があった。
/* * As we do 4.4BSD message passing we use a 4.4BSD message passing * system, not 4.3. Thus msg_accrights(len) are now missing. They * belong in an obscure libc emulation or the bin. */ struct msghdr { void * msg_name; /* Socket name */ int msg_namelen; /* Length of name */ struct iovec * msg_iov; /* Data blocks */ __kernel_size_t msg_iovlen; /* Number of blocks */ void * msg_control; /* Per protocol magic (eg BSD file descriptor passing) */ __kernel_size_t msg_controllen; /* Length of cmsg list */ unsigned msg_flags; };
kernelでネットワークのレスポンスを扱うにはなにやらこれがいいらしい。
実装の前に
全体の流れを整理する。
- 必要なsocket類を構造体などで宣言する。
- listenをするスレッドを作る
- 上記のスレッド内でsocketを作成、bind、listenなどを行う
- それが完了したら更にacceptを行うスレッドを作る
- 文字列が送信されてきたら、それを送り返す
実装する
実装してみた、結果はこちら。
ヘッダーファイルに直書きしているのは後で直す。
ただし、実行してみるとaccept errorと表示されている。
[ 689.884212] accept_thread the csock is :474605440,474606080 [ 689.884216] accept start [ 689.884220] accept error
なるはやで解決しないといけないものは
accept errorと表示されるので、上記のopsを見なおしてなぜそこでコケたのか調べる。
あとrmmodを実行した際に
rmmod: ERROR: ../libkmod/libkmod-module.c:793 kmod_module_remove_module() could not remove 'fastecho': Device or resource busy rmmod: ERROR: could not remove module fastecho.ko: Device or resource busy
といったエラーが出てinsmodするために再起動しないといけない。
それはだるいのでどうにかしたい。
以上、学生アドベントカレンダー25日目の記事でした。
全てのプログラマに捧げるScala入門
はじめに
Qiitaの方に次のようないくつかのScala入門記事を掲載していた。
java経験者のScala入門メモ [基礎知識] - Qiita
java経験者のScala入門メモ [関数、クラス] - Qiita
java経験者のScala入門メモ [ケースクラス、オブジェクト] - Qiita
java経験者のScala入門メモ [トレイト、メソッド] - Qiita
しかし、これらは自身がScalaを学習し始めた直後に書いたもので
内容の正確性と充実性がいまいちなのでこれを書き直すことにした。
対象は、Javaを使っていてScalaの使用を考えている人。を想定しているが
Java以外の言語を使っている人や単に興味がある人にも楽しんで貰えればと思っている。
対応するバージョンは2.11.xと2.12.xとなる。
ただし、この記事群はあくまで入門編なので
理解が難しい点や現状で解説しても混乱を招くことが想定されるものは除外しているので
その点はご理解のほどをお願いしたい。
Scala入門
Scalaがある程度使えるぐらいまででいいという方はコレクションまで
もう少し使ってみたいという方は最後まで読んで頂けるとある程度の入門にはなるだろう。
以下の記事は本アドベントカレンダー用の記事として作成した。
- Scalaの基本
- クラスとオブジェクト、ケースクラス
- トレイト
- ラムダと高階関数、カリー化
- コレクション
- パターンマッチ
- 暗黙の型変換
- 型パラメータ
- 例外
これら3つに関してはまた別の機会に書くことにする。
参考文献
- Scala スケーラブルプログラミング 第3版
- Scala 公式ドキュメント
A Scala Tutorial for Java Programmers | Scala Documentation
- Scalaメモ
Scalaメモ(Hishidama's Scala Memo)
- Scalaでリスト処理
- 第18章 Scalaのパターンマッチ
さいごに
この記事は Muroran Institute of Technology Advent Calendar 2017 24日目の記事となる。
今回は特に書くことがなかったのでScalaの入門記事を更新することにした。
いくらアドベントカレンダーといえど7個も記事書くのしんどかった。
全てのプログラマに捧げるScala入門 パターンマッチ
はじめに
前回はコレクションについてさらっと触れたが今回は、パターンマッチについて触れる。
しかし、例によってパターンマッチは用途がかなり多いのでここでは基礎的なことにのみ限定して紹介する。
パターンマッチ
match文というのがScalaには存在する。
例えば、次のコードを例に考えてみよう。
scala> def judge(n: Int): String = n match { | case 1 => "one" | case 2 => "two" | case _ => "error" | } judge: (n: Int)String scala> (1 to 5).toList.foreach( num => println(judge(num)) ) one two error error error
match文は直前に渡される変数に束縛され実行する。実際に今回はnという変数に束縛されている。
今回は定数パターンでのみ分類したが最初の2つがnが1 or 2のとき最後のものがそれ以外の時を指す。
この程度であれば、if式などを使った方が断然早く楽に感じる。
しかし、このパターンマッチは単に値を格納した変数だけでなく型やその他もろもろのものに対して適用できるのでif式などよりも汎用性が高い。
これ以降はほかにどんな状況が想定できるか解説していく。
型パターン
型についてもパターンマッチを適用できる。
scala> val list = List(1, "hello", true, 1.0) list: List[Any] = List(1, hello, true, 1.0) scala> list.foreach(value => value match { | case number: Int => println(number) | case str: String => println(str) | case bool: Boolean => println(bool) | case _ => println("error") | }) 1 hello true error
このように、case後の変数名後にデータ型を書くことができて
それについて処理を分けることもできる。
ただし、最後のcaseで指定しているワイルドカードパターンがなければ
リストの末尾にある、Double型の変数がマッチしないためにエラーが発生する。
つまりパターンマッチは、なにかしらのパターンにマッチさせなければいけないということになる。
変数パターン
これは先程のものと同じかと思うが少し違う。
scala> val num = 2 num: Int = 2 scala> val res = num match { | case num => num * 2 | } res: Int = 4
これは計算できるかぎりの全てのパターンにマッチする。
そしてマッチしたものは変数に束縛させて処理を行っている。
シーケンスパターン
お次はシーケンス型のパターンにマッチするものである。
scala> val list = List(1,2,3,4) list: List[Int] = List(1, 2, 3, 4) scala> val res = list match { | case List(1, a, _*) => a | case _ => -1 | } res: Int = 2
先頭要素が1で要素が2個以上のシーケンス型のコレクションにマッチするものに成る。
タプルパターン
これは個人的に、ネットで情報を探していて一番おもしろかったので紹介する。
有名なFizzBuzzを解くプログラムを例にする。これはタプルを上手に使った面白い解法だった。
object Sample{ def main(args: Array[String]):Unit = { (1 to 30).foreach( num => println(judge(num)) ) } def judge(n: Int): String = (n%3, n%5) match { case (0, 0) => "FizzBuzz" case (0, _) => "Fizz" case (_, 0) => "Buzz" case _ => n.toString } }
割ったあまりをタプルとして格納して、それを元にマッチさせている非常にスマートな解法だった。
パターンガード
これは定数パターンに通じるものだが、定数や変数を扱う際にそのマッチに更に条件をつけることができるものである。
scala> val n: Int = 5 n: Int = 5 scala> val res = n match { | case n if n%2 == 0 => true | case n if n%2 != 0 => false | } res: Boolean = false
おわりに
この他にもまだコンストラクタパターンなどがあるが実際にライブラリ等を使用した際によく使うものであるので
興味があれば他のパターンマッチについても学習して欲しい
全てのプログラマに捧げるScala入門 コレクション
はじめに
この記事ではScalaのコレクションについて解説する。
しかし、コレクションをすべて隅から隅まで紹介するにはこの一つの記事では難しいため
特によく使うものに厳選して解説する
コレクション
コレクションにはmutable(可変)とimmutable(不変)のものが存在するため
まずそれらについて解説し、その後にそれらを踏まえた性能の特性について解説する。
特に、immutableであるコレクションを使う際にはそれぞれの性能特性を理解しておくことが
パフォーマンス的に重要になってくる。
不変と可変
不変と可変はこれ以前の記事で解説した、valとvarに似たとようなものである。
しかし、コレクションとこれらを併用することで微妙な差が出てくる。
ここでは特にそれを紹介する。
コレクションにおける不変と可変
次のようなimmutableなリストを例として挙げる。
val list: List[Int] = List(1,2,3,4,5)
このリストに対して、インデックスを使用して値を参照する場合は
applyメソッドか()でインデックスを指定する。
list(0) //return -> 1 list.apply(1) //return -> 2
インデックスを取得できるなら値の更新ができるはずだが、immutableリストではそうならない。
scala> list(0) = 10 <console>:9: error: value update is not a member of List[Int] list(0) = 10 ^
エラーにも出ているがimmutableなコレクション、今回の場合で言えば特にイミュータブルリストは
updateという値の更新をするメソッドが存在しないために更新できない。
immutableとは内部の値も更新できない、つまりは内部状態が不変なコレクションと言える。
それでは値を更新したい場合はどうするのか。
解決策は至って簡単でListを作りなおすことである。
先頭に要素を追加する場合と末尾に要素を追加する場合の2つを紹介する。
scala> 0 :: list res4: List[Int] = List(0, 1, 2, 3, 4, 5) scala> list :+ 6 res5: List[Int] = List(1, 2, 3, 4, 5, 6)
このように::と:+を使うことでそれぞれ先頭追加、末尾追加が行える。
そして、値を追加した後、新しいリストが返ってきている。
しかし、これを次のように再代入はできない。
scala> 0 :: list res4: List[Int] = List(0, 1, 2, 3, 4, 5) scala> list :+ 6 res5: List[Int] = List(1, 2, 3, 4, 5, 6)
というのも、listという変数は今valで宣言されており
値を追加したimmutableなリストは新しいListオブジェクトとなっているので
valにおいては参照するオブジェクトが変更されることに等しいので再代入はできない。
なので、実際に上記のコードのように再代入したいのなら変数はvarで宣言する必要がある。
それでは次にmutableリストについて解説する。
immutableリストを解説したあとだとこちらはわかりやすいかもしれない。
まずmutableリストを使うにはcollection.mutableパッケージをインポートする必要がある。
import scala.collection.mutable.ListBuffer
mutableなリストはMutableListが存在するが実際にはListBufferを使うことが多いと思うので
今回はそちらをインポートする。
そして先ほどと同様にリストを宣言する。
scala> val list: ListBuffer[Int] = ListBuffer(1,2,3,4,5) list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5)
valで宣言していことを覚えておきながら値の更新を行う。
//index = 0の値を2に更新 scala> list.update(0, 2) scala> list.foreach(println _) 2 2 3 4 5
更新が正常に終了している。
valで宣言したmutableコレクションの値を更新することが出来たのは
コレクション、今回ならListBufferのオブジェクト自体に変更はなく
変更されたのはコレクションの内部状態であるからvalでも変更ができた。
これと同様に、先頭や末尾への追加がおこなえる。
性能特性
性能特性に関しては、いちからまとめるより公式のドキュメントがよくまとめているのでそちらを紹介する。
特に気をつけたいのは線形と定数となっている部分である。
例えばimmutableなListでは末尾への追加が線形になっていて先頭への追加が定数となっている。
これが意味することは末尾への追加はその要素数分だけコストがかかり、先頭への追加は一定のコストしかかからないということである。
もし要素数が多いリストに値を追加するなら最初から先頭追加にして、
追加が完了した段階でreverseなどをつかって逆順にすることの方が賢い方法と言える。
シーケンス
ここでは特によく使うシーケンスのコレクションについてのみ解説する。
シーケンスとは要素が順序をもっておりインデックス等で要素を指定できるコレクションのことである。
先ほど紹介したListもシーケンス型のコレクションに含まれている。
リスト
Scalaにおけるリストは次のような構造になっている
List(1,2,3, ..., n)
これをもっと掘り下げると次のような構造になっている。
1 :: 2 :: 3 :: ... :: n :: Nil
先頭追加のメソッドが連続した状態で、末尾がかならずNilになっている。
データ型については前章を見てもらうとわかるが型推論でIntになっている。
これが例えばIntとDoubleが混在したリストだとどうなるだろうか?
List(1,1.0) res4: List[Double] = List(1.0, 1.0)
IntはDoubleにキャストできるためDoubleのリストとして解釈され、Intの要素もDoubleに変換されている。
では次にIntとStringの混在リストはどうなるだろうかやってみよう。
scala> List(1, "hello") res5: List[Any] = List(1, hello)
すべてのクラスの親クラスであるAny型に推論されている。
推論はされているが、実際はこのようにいくつかの型をまとめるようなデータ構造は避けるべきである。
次にリストのなかでよく使うメソッドを一気にコードとして紹介する。
//Listでは無いものをListに変換する scala> val list = (1 to 10).toList list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //先頭要素を求める scala> list.head res0: Int = 1 //先頭以外を求める scala> list.tail res1: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10) //サイズを求める、sizeでもいい scala> list.length res2: Int = 10 //空かどうかを求める scala> list.isEmpty res3: Boolean = false //末尾要素を求める scala> list.last res4: Int = 10 //末尾以外を求める scala> list.init res5: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9) //先頭からn分だけリストにする scala> list.take(5) res6: List[Int] = List(1, 2, 3, 4, 5) //末尾からn分だけリストにする scala> list.takeRight(5) res7: List[Int] = List(6, 7, 8, 9, 10) //先頭の要素n個を除いたものを求める scala> list.drop(5) res8: List[Int] = List(6, 7, 8, 9, 10) //末尾の要素n個を除いたものを求める scala> list.dropRight(5) res9: List[Int] = List(1, 2, 3, 4, 5) //引数が含まれているか求める scala> list.contains(5) res11: Boolean = true //逆順にする scala> list.reverse res12: List[Int] = List(10, 9, 8, 7, 6, 5, 4, 3, 2, 1) //最大値 scala> list.max res13: Int = 10 //最小値 scala> list.min res14: Int = 1
配列
リストだけでなく当然配列も存在する。
配列は要素のシーケンスを保持することができて、任意の要素に対して一定のコストでアクセスできる。
一般的な配列はScalaだと次のようにかける。
//要素数5で作成 val array = new Array[Int](5)
もちろんListのようにパラメータでも初期化できる。
メソッドに関してもほとんどListと同じで大きな違いといえば性能面になる
バッファ
最初に紹介したListBufferと同様に、mutableな配列やシーケンスは大抵****Bufferの名前え存在する。
これは内部状態がミュータブルであるが、利用できるメソッドとして大きな違いはない。
コレクションと関数
ここではリストの要素に関数を適用して新しいリストを求める場合について行う。
前の記事で紹介したラムダ式を多用することになる。
map
これは新しいリストを返す制御構造のなかで特に使うものであり次のように使用する。
scala> val list = 1 to 10 toList list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> list.map(num => num * 2) res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
関数にたいして要素を一つずつ適用し、返ってきた値を新しいリストとして生成しているのがわかる。
この程度であればわざわざ明示的にラムダを書く必要がなくワイルドカードを使用して簡潔にかくことができる。
scala> val list = 1 to 10 toList warning: there was one feature warning; re-run with -feature for details list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> list.map(_ * 2) res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
filter
これは評価式をもつ関数を渡し、それに対して要素が真であるmのをリストとして返すものである。
使い方自体はmapと同じになる。
scala> list.filter(num => num % 2 != 0) res1: List[Int] = List(1, 3, 5, 7, 9)
foreach
これはリストの要素に対して、繰り返し処理をする時に使う。
よく使うのは要素の表示など
scala> list.foreach(println _) 1 2 3 4 5 6 7 8 9 10
ただし、新たなコレクションが返ってくるわけではない。
おわりに
ここではまだ紹介していないMapやSet、Tuppleなどのコレクションや
畳み込みなどのメソッドがあるので、Scalaをもっと使いこなすにはそれらへの理解も必要になるだろう。
次はパターンマッチについての紹介になる。
全てのプログラマに捧げるScala入門 トレイト
はじめに
Scalaで規模の大きいプログラムを作成する場合にモジュール化するのは非常に重要なことである。
そこでモジュール化のための機能をココでは紹介する。
JavaにおけるInterfaceと同等の機能を持つtraitである。
トレイト
トレイトとは次の様に宣言する。
trait Name{
}
宣言自体はtraitというキーワードを使うだけなので宣言は比較的簡単である。
それでこのトレイトで何が出来るかというとメソッドとフィールドの定義を持つことができる。
ScalaのトレイトはほとんどJavaのInterfaceと同じであるが、決定的に違う点がある。
それはinterfaceの様な機能を持ちながら、メソッドが宣言のみで処理を持たないものだけでなく
実装をもったメソッドも含めることが出来るという点である。
実装をもつメソッドも含めるということはそれだけ機能を抽象化するだけでなく
カプセル化できるという利点がある。
では実際に自身がTwitter4SというScalaで書いたTwitterAPIのラッパーライブラリ内で使用しているトレイトを例に挙げてみよう。
trait StatusBase { /** * @param text * @return response json as Status */ def updateStatus(text: String): Status }
実際に処理がない宣言のみのメソッドを持っているがこれはエラーにならずトレイトの要素として認められる。
上記のメソッドには実装がないため、このトレイトをミックスインしたクラスでオーバーライドしなければならない。
それではクラスとほとんど変わらないのでは?と思うかも知れないが
クラスともまた違う点がある。それは次の点である。
最初の2つはともかくとして、ミックスインはモジュール化やトレイトを使う上で重要なので説明していく
ミックスイン
クラスにトレイトを実装する場合やトレイト自身に別のトレイトを継承(厳密にはこれもミックスインというが)することをミックスイン合成という。
どのように使うかというと次のように使う。
trait TraitA class Sample extends TraitA //これはミックスイン class SubSample extends Sample with TraitA // withキーワードでもミックスインとなる //traitにtraitをミックスインする場合 trait TraitB extends TraitA trait TraitC extends TraitA with TraitB
1つめでミックスインするならextends、ふたつ目以降はwithキーワードを使う。
ただしクラスを継承する場合は優先的にextendsを使わないとエラーとなる。
ここまで聞くと、インスタンス生成やコンストラクタを持てないクラスが多重継承できると思うが(クラスは多重継承できない)
実際に多重継承でなくても、実質的に多重継承の様な機能を持っていることになる。
おわりに
ここまでで、大規模なコードを書く上で重要なモジュール化の役割を果たすトレイトについて解説した
次は、ラムダや高階関数、カリー化についてまとめる。
全てのプログラマに捧げるScala入門 クラスとオブジェクト、ケースクラス
はじめに
前回の続きで、今回はクラスとオブジェクトについてまとめていく。
その前に、メソッドについて触れていなかったのでそこもまとめる。
メソッド
Scalaにおけるメソッドとは次の形をとる。
(private or protected [this or package_name]) def methodName(arg0: DataType, arg1: DataType, ... argN: DataType): ResultDataType = ???
これだけではわかりにくいのでざっくりと解説すると
アクセス修飾子やthis, package_name等は必要に応じて任意でつける。
defがメソッドを宣言するキーワードとなり、0個以上の引数を持つ。
最後に戻り値のデータ型、つまり結果型を記述し=の後に式を書いていく。
式ということなので{}式を用いて複数の式を入れることも可能。
privateやprotectedをつけない場合はpublicとみなされる点はJavaと異なるので注意が必要である。
[this]とすればそのクラス内だけから、[package_name]とすると同一パッケージ内のみからのアクセスが可能となる。
よく使うのは次のような形となる。
private [this] def getXXX(): Int = 0
クラス
Scalaのもつクラスはコンストラクタの記法を除いてほとんどJavaと同じである。
というのもコンストラクタを特に使用しない場合は次の様に記述するからです。
//これはScalaのクラス class ClassName{ }
これでコンストラクタを使う場合は次のようになる。
class ClassName(param1: DataType, ... ,paramN: DataType){
}
()で囲んだパラメータリストをクラス名の横に付与するとそれがコンストラクタになる。
例として、コンストラクタの値をフィールドに代入するコードを上げると次のようになる。
class SampleClass(num1: Int, num2: Int){ val number1: Int = num1 val number2: Int = num2 }
このようなクラスはJavaでインスタンスを生成するようにnewでインスタンスを生成することができる。
コンストラクタに対しての引数の渡し方も同様に次のようにできる。
val inst: SampleClass = new SampleClass(1, 2)
継承
ScalaのクラスはほとんどJavaと同じわけなので継承に関しても次のようになる。
class SubClass extends SuperClass{ }
見かけは同じなのだが少しだけ違いがある。
クラスにおいて継承した既存のメソッドをオーバーライドする場合、Javaでは@Overrideというアノテーションを付与したが
Scalaにおいてはoverrideキーワードになる。
なので、仮にtoStringメソッドをオーバーライドするときは次のようになる。
overrideキーワードをつけるのは継承したメソッドだけでなくオーバーライドする全ての場合に適用される。
override def toString(): String = ???
補助コンストラクタ
ここまでの内容を把握してみて、ひとつ疑問に思うことはないだろうか。
それはコンストラクタのオーバロードをどうするかという問題である。
それに関しては解決策があり、補助コンストラクタを用いるものである
これはJavaでいうコンストラクタのオーバロードと似ているが決定的にことなる部分がある。
まずは補助コンストラクタの使い方から見てみよう。
例はコップ本にある分数を扱うクラスを参考に一部改変し、簡略化したものを使う。
object Sample{ def main(args: Array[String]):Unit = { val sample: Rational = new Rational(1,2)// 1/2 val ratinal: Rational = new Rational(2) } } class Rational(val n:Int, val d:Int){ //コンストラクタから値を受け取り初期化 val numer: Int = n val denom: Int = d def this(n:Int) = { this(n,1) //ここに処理があってもいい } //toStringメソッドをオーバーライド override def toString(): String = numer + "/" + denom }
このコードにおいて、補助コンストラクタは次の部分である
def this(n:Int) = { this(n,1) //ここに処理があってもいい }
このようにdef thisというメソッドが補助コンストラクタとなる。
しかしこの補助コンストラクタというものを使うときには
thisを使い必ず先頭でそれより前に定義されたコンストラクタを呼び出す必要がある。
オブジェクト
Scalaにおいて全てはクラスであり、値はオブジェクトとして存在しメソッドは何らかのオブジェクトとなっている。
その状態を考えるとクラスに属するstaticなものを生成することができない。
しかし、その状態は不便なのでobjectキーワードがそれを解決する。
objectがあると何が嬉しいのかというと、objectで指定したシングルトンオブジェクトを生成することが出来る点である。
シングルトンオブジェクトであるが故に、そのオブジェクト固有のメソッドやフィールドを扱うことができる。
シングルトンオブジェクトを作ることができるなら、それによる恩恵を受けることができる。
そうなると、ユーティリティメソッドやオブジェクトのファクトリメソッドなども扱うことができる様になる。
それでは早速使ってみる。
といっても宣言から継承などほとんどクラスと変わらない上に、実はもう一度登場している。
それはHelloWorldを出力した時である。
object Sample{ def main(args: Array[String]): Unit = { println("hello,world") } }
この時にすでに使っている。
これによりmainメソッドがJavaでいうところのstaticメソッドになっている。
唯一といってもいい大きな違いはコンストラクタとしてパラメータを受け取れない点にある。
ケースクラス
最後に、クラスでもオブジェクトでもない特別なクラスを紹介する。
それはケースクラスというものでこの後に登場するパターンマッチという機能にも関連するものである。
ケースクラスとは次の様に宣言する。
case class User(name: String, age: Int)
これを見ると早いのだが、classの宣言の前にcaseキーワードが付いただけである。
一見なんら変化が無いように思えるがケースクラスには次のような利点がある
- コンストラクタ引数にvalが付いた状態で自動的にそのクラスのメンバとして宣言される
- パターンマッチに使える
- 便利なメソッドが自動生成される
今回はこれの特に自動生成されるメソッドについて、とくにapplyについて触れる。
applyメソッド
実際、自動生成されるメソッド群のなかでこれが一番使われていると思う。
applyメソッドはそのケースクラスのインスタンスを生成する。
ということはこれを使うことでnewをする必要がなくなる。
上記のUserクラスをそのまま例で使う。
caseクラスのインスタンス生成の仕方は以下の通りである
val user :User = new User("scala", 20) //これでも生成できる val user :User = User.apply("scala", 20) //こっちでもok
おわりに
ここまでで、一通りクラス、オブジェクト、ケースクラスについては解説した。
次はJavaでいうinterfaceに類似した機能をもつtrait(トレイト)について解説する。
全てのプログラマに捧げるScala入門 Scalaの基本編
Scalaでコードを書く
Javaでコードを書く時の最小単位は次の様なものを書くだろう。
public class Hello{ public static void main(String... args){ System.out.println("Hello,World!!"); } }
クラス名とファイル名が一致し、mainメソッドを持つお馴染みの形である。
これがScalaだとどうなるかと言えば、次のようになる。
object Hello{ def main(args: Array[String]): Unit = { println("Hello,World!!") } }
classではなくobjectというキーワードを使い(これは後述する)、
mainメソッドをdefで定義し標準出力はprintln()という様に短くなる。
そして文末のセミコロンもいらない。しかし任意につけることは出来る。
Unitなどは後の、データ型で詳しく説明する。
ScalaにはREPLがあるので、それを使うともっとコードは短くなる。
これがREPLを使わない時のScalaプログラムの基本形である。
変数
Javaで変数の宣言をするときは次のような形式を取る
int i = 0; String str = "Hello";
つまりは
(アクセス修飾子)[データ型] [変数名]; or (アクセス修飾子)[データ型] [変数名] = [初期値];
と言った形である。
これに対してScalaは次のような形式を取る。
val str: String = "Hello" var i: Int = 0 var number = 1L //val number:Long = 1L
つまりは
(アクセス修飾子) [val or var] [変数名] : (データ型) = [初期値]
となっている。
ここで重要なのがval,varとデータ型である。
変数宣言の先頭にある、valとvarで何が違うのかというと再代入が可能かどうかで
Javaでいうところのfinalが付与される動作に似ているのがvalで、非finalな変数がvarとなる。
実際に次のようにvalに値を再代入するとエラーが発生し、再代入が出来ないことを確認できる。
scala> val index: Int = 0 index: Int = 0 scala> index = 1 <console>:8: error: reassignment to val index = 1 ^
これに対してvarは再代入ができることを確認するのが次のREPLになる
scala> var index: Int = 0 index: Int = 0 scala> index = 1 index: Int = 1
var,valでどちらを使うのが良いかと思うかも知れないが、Scalaでは基本的にvalを使用することが多い。
というのも関数型的な側面を活かすには変数等はイミュータブルの方が望ましいからである。
ネットでは何がなんでもvalを使えという過激派な意見も見受けられるが、実際にScalaの標準ライブラリの実装では
ミュータブルな変数やコレクションなんかが多用されているので一概にどちらかだけを使えとは言えない。
データ型
ScalaにはJavaの様なプリミティブ型が存在しない。
ではなにが存在するかといえば、全て参照型でありつまりはクラスの値なのだ。
Scalaは拡張性が高くスケーラブルであるという最大の要因であると言える。
つまりはJavaからプリミティブが消えて、それに対応しているラッパークラスのみが残った状態と言える。
ここまでで、そのように説明されてもいまいちしっくりこないだろう。
そこで次の例を用いてInt型について考えてみる。ここでのIntは前述の通りクラスである。
まだその点において疑問を持つ人は次のリンクを参照してみるといい。
github.com
val a: Int = 1 val b: Int = 2 println(a + b) //out -> 3
気になるのが
a + b
という構文である。
Int型がクラスであるというなら、通常このように書くはずであると考えるし
そもそも+という名前のメソッドを書けるのかと疑問に思うだろう。
a.+(b)
Scalaをさわったことが無い人なら誰でもそのように感じるだろう。
その考えは全て正しいが、Scalaにおいては全てがクラスとそのメソッドなので+という演算子そのものが
言語レベルでサポートされているわけではなく、あくまでもそのクラスのひとつのメソッドにすぎない。
今までの言語と似た感じで使用できるのは、メソッドの呼び出しで.や()を省略できる場合があるからである。
ここまで話して、Scalaにおいてのデータ型とは参照型を指すということがわかるだろう。
また演算等についても自身で作成することができるのでデータ型を自作できるという面で非常に拡張性が高くなっている。
Scalaのデータ型とはそういうものなのだ。
制御構文
ここまでで変数とデータ型について触れたので、基本的なifやwhile、forといった制御構文についてここでは触れようと思う。
{}式
これについてはあまり触れられていないが、if文やwhile文ではなくif式やwhile式であるScalaにおいて複数の式を
記述する場合にこれは非常に重要な役割を持つ。{}式は次のようにいくつかの式を含む。
{ exp1; exp2; .... expn;}
これは順番に1~nの順で評価される。
if式
これはほとんどjavaのif文のように使えるが、それに馴染みすぎた人にはすごく奇妙な性質を持つ。
というのを、次のかなり有名な例を基に考えてみる。
Javaでは、年齢を数値として考えるとき次の様にすることが多い。
int age = 21; String res; if(age < 20){ res = "未成年"; }else{ res = "成人"; } System.out.println(res); //out -> "成人"
if~else文で評価式に応じて変数に値を代入しているがScalaでは次のように書くことが多い。
val res:String = if(age < 20) "未成年" else "成人" println(res) //out -> 成人
この処理を見てもらうとわかるのだがif式が式であるがゆえに値が返っている。
また{}式も併用も可能であり、else if,elseも使うことができる。
while式
while式もif式同様に値を返すが適切な値がない(これは書いてみるとわかると思う)ためUnit型の()が返る
基本的にはjavaのwhile文と同じなので省略。
for式
ここまでのif,whileは基本的にJavaの制御構文と同様に使えるがforはかなり奇妙な使い方をする。
一般的にJava等の言語でfor文と言えば次を想像するだろう。
for(int i = 0; i < 10; i++){ System.out.println(i); }
しかしこれをScalaで書くと次のようになる。
for(i <- 0 until 10) println(i)
どちらかというとPythonに近い感じで書ける。
untilでなくtoも存在するが、これに共通しているのはループ変数の増減ではなくコレクションを対象に行うことである。
もちろんListやMap等でも同じようにループを回せる
Scalaのfor文は次のようにも書ける。
これは多重ループのように機能する。
for( x <- 1 to 5; y <- 1 to 5; if x != y) println(s"x : y = ${x} : ${y}") x : y = 1 : 2 x : y = 1 : 3 x : y = 1 : 4 x : y = 1 : 5 x : y = 2 : 1 x : y = 2 : 3 x : y = 2 : 4 x : y = 2 : 5 x : y = 3 : 1 x : y = 3 : 2 x : y = 3 : 4 x : y = 3 : 5 x : y = 4 : 1 x : y = 4 : 2 x : y = 4 : 3 x : y = 4 : 5 x : y = 5 : 1 x : y = 5 : 2 x : y = 5 : 3 x : y = 5 : 4
この時点でも、かなり奇妙だがScalaのfor式はyieldというキーワードを使うことで
コレクションの要素を加工し新たなコレクションとして返すことができる。
for(i <- List(1, 2, 3, 4, 5)) yield { i + 1 } //return List(2, 3, 4, 5, 6)
最後に
ここまでがScalaの基本となるあれこれである。
次回はクラスとオブジェクトについてまとめようと思う