最速のEchoサーバーを目指して、LinuxKernelモジュールを作っていく part4
はじめに
前回、実装したはずの機能で特にacceptでコケる問題がなかなか解決出来なかったので
毎回おなじみになりつつあるこのサイト
linux/include - Elixir - Free Electrons
さらに今回は、この本も参考にして書いていく
www.oreilly.co.jp
まず色々、調べたりしたことをまとめてその後に本題に入ろうと思う
色々やる前のメモ
実際に動いたであろうサンプルソースを参考にああだこうだ考えながら書いていたがacceptでコケる。
省略していた待ち行列が関係してるのではと思っている。
そもそも、エラーコード返ってきてるのにそれを見てなかったから見てみる。
見てみた。
$dmesg .... .... [524524.095520] Fastest Echo Server Start!! [524524.095544] accept error no:-11 $
なんか、acceptでエラーが返ってきている。
それを上記のサイトで調べる。
まずはacceptの実装から。
acceptの実装は次のようになっていた。
static int accept(struct socket *sock, struct socket *new_sock, int flags) { struct sock *sk = sock->sk; struct sk_buff *buf; int res; lock_sock(sk); if (sock->state != SS_LISTENING) { res = -EINVAL; goto exit; } while (skb_queue_empty(&sk->sk_receive_queue)) { if (flags & O_NONBLOCK) { res = -EWOULDBLOCK; goto exit; } release_sock(sk); res = wait_event_interruptible(*sk_sleep(sk), (!skb_queue_empty(&sk->sk_receive_queue))); lock_sock(sk); if (res) goto exit; } buf = skb_peek(&sk->sk_receive_queue); res = tipc_create(sock_net(sock->sk), new_sock, 0, 0); if (!res) { struct sock *new_sk = new_sock->sk; struct tipc_sock *new_tsock = tipc_sk(new_sk); struct tipc_port *new_tport = new_tsock->p; u32 new_ref = new_tport->ref; struct tipc_msg *msg = buf_msg(buf); lock_sock(new_sk); /* * Reject any stray messages received by new socket * before the socket lock was taken (very, very unlikely) */ reject_rx_queue(new_sk); /* Connect new socket to it's peer */ new_tsock->peer_name.ref = msg_origport(msg); new_tsock->peer_name.node = msg_orignode(msg); tipc_connect2port(new_ref, &new_tsock->peer_name); new_sock->state = SS_CONNECTED; tipc_set_portimportance(new_ref, msg_importance(msg)); if (msg_named(msg)) { new_tport->conn_type = msg_nametype(msg); new_tport->conn_instance = msg_nameinst(msg); } /* * Respond to 'SYN-' by discarding it & returning 'ACK'-. * Respond to 'SYN+' by queuing it on new socket. */ if (!msg_data_sz(msg)) { struct msghdr m = {NULL,}; advance_rx_queue(sk); send_packet(NULL, new_sock, &m, 0); } else { __skb_dequeue(&sk->sk_receive_queue); __skb_queue_head(&new_sk->sk_receive_queue, buf); } release_sock(new_sk); } exit: release_sock(sk); return res; }
この中で、一通り関係しそうなものをerror.hとかerror-base.hから探してみる。
そうすると
#define EWOULDBLOCK EAGAIN
が返っていることがわかり今度はこのEAGAINを調べた。
すると、こいつが例の11番のエラーを返していた。
ただ
#define EAGAIN 11 //try again
とあり、何をtry againすればいいのかわからなかった。
そこでaccept関数の実装をみて、どこでこのエラーが返ってきてるか調べてみることにした。
するとここの処理が影響していることがわかった。
while (skb_queue_empty(&sk->sk_receive_queue)) { if (flags & O_NONBLOCK) { res = -EWOULDBLOCK; goto exit; } release_sock(sk); res = wait_event_interruptible(*sk_sleep(sk), (!skb_queue_empty(&sk->sk_receive_queue))); lock_sock(sk); if (res) goto exit; }
skb_queue_emptyが返す値が真であるならO_NONBLOCKをflagsとして渡しているので
今回のgotoで該当の処理がスキップされエラーとなってしまうためskb_queue_emptyが返す値が偽である必要がある。
skb_queue_empty関数に渡しているものは
&sk->sk_receive_queue
という構造体の値である。
そもそもこのskが何かというとaccept関数の先頭で宣言、初期化されている次のものである。
struct sock *sk = sock->sk;
右辺のsockはaccept関数に渡している第一引数である。
そして問題のskb_queue_empty関数は次のようになっている。
static inline int skb_queue_empty(const struct sk_buff_head *list) { return list->next == (struct sk_buff *)list; }
これはソケットバッファに関するキューの様でリストの次の要素と先頭要素が等価であることを調べている(っぽい)。
これとはまた別にO_NONBLOCK、ノンブロッキングIOについてもよくわかっていなかったのでそれも別途記述していく。
ノンブロッキングI/O
カーネルモジュールで、TCPソケットを使おうとしたらほとんどのソースにO_NONBLOCKが出てきてなんだこれはと調べると
次のサイトに色々まとまっていた。
ノンブロッキングI/OではI/O対象のファイルディスクリプタの準備完が了していないことをアプリケーション側に伝えるため即座にエラーが返る(errnoにEGAINが格納されて返ってくる)。一般に、O_NONBLOCKフラグを利用してノンブロッキングモードを宣言するが、この時プロセスはブロック状態にならず、CPUを他の処理に回すことができるためI/O待ち時間を有効活用できる。
ノンブロッキングI/Oはソケットなどのネットワークに用いられるI/OモデルでディスクI/Oには使わない。
これに関連していたのがO_NONBLOCKを使用していたacceptであった。
次のManPageを参照すると色々わかった。
Man page of ACCEPT
キューに保留となっている接続要求がなく、 かつソケットが非停止になっていないときは、 accept() は接続が発生するまで呼び出し元を停止 (block) する。 ソケットが非停止になっていて、 待ち状態の接続要求がキューに無いときは、 accept() はエラー EAGAIN か EWOULDBLOCK で失敗する。
これが最も自分を苦しめたあれである。
そもそも今回は、このキューを使っていなかった。
そのため、待ち状態の接続要求がキューになく(そもそもキューを用意していなく)、acceptがEAGAIN,EWOULDBLOCKを返していた・
おわりに
そんなこんなで、tcpクライアントからメッセージを受け取り表示するところまではできた。
コードは以下のレポジトリにある。
github.com
使ったtcpクライアントはpythonで書いたものを使用した。
#!/usr/bin/env python # -*- coding: utf-8 -*- import socket target = "localhost" port = 8888 #using IPv4 and TCP/IP client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #connecting client_socket.connect( (target, port) ) #data send client_socket.send("hello,world") #get data response_data = client_socket.recv(1024) print response_data
ただ、データの送信が出来ないことに加えて、時折メッセージを受信出来なかったりするのでそのあたりのバグとリファクタリングは今後も行っていく必要がある
最速の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の基本
- クラスとオブジェクト、ケースクラス
- トレイト
- ラムダと高階関数、カリー化
- コレクション
- パターンマッチ
- 暗黙の型変換
- 型パラメータ
- 例外
これら３つに関してはまた別の機会に書くことにする。
参考文献
- 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という変数に束縛されている。
今回は定数パターンでのみ分類したが最初の２つが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を作りなおすことである。
先頭に要素を追加する場合と末尾に要素を追加する場合の２つを紹介する。
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
これは評価式をもつ関数を渡し、それに対して要素が真であるｍのをリストとして返すものである。
使い方自体は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 }
実際に処理がない宣言のみのメソッドを持っているがこれはエラーにならずトレイトの要素として認められる。
上記のメソッドには実装がないため、このトレイトをミックスインしたクラスでオーバーライドしなければならない。
それではクラスとほとんど変わらないのでは？と思うかも知れないが
クラスともまた違う点がある。それは次の点である。
最初の２つはともかくとして、ミックスインはモジュール化やトレイトを使う上で重要なので説明していく
ミックスイン
クラスにトレイトを実装する場合やトレイト自身に別のトレイトを継承(厳密にはこれもミックスインというが)することをミックスイン合成という。
どのように使うかというと次のように使う。
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
１つめでミックスインするなら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(トレイト)について解説する。
