Life-LOG OtherSide

  

じっくりとゆっくりとプログラミングの勉強は進んでいます。最近になってやっと進歩の実感を感じられるようになったところです。

「Swiftで遊ぼう！ - 76 プロおも本、クラスの問題」でかなり悩んでいましたね。先日、このブログを読んでくださっている藤原さんからヒントのコメントを頂いたのでそれを契機に再びこの問題に取り組みました。「アプリを作ろう」シリーズを楽しみにしている方(そんな人いないかもしれませんが)はもうしばらくお待ちください。新年度から再開させます。

じゃあ問題をもう一度見よう。

問題：学生名簿を管理するクラスを設計してみよう。学生レコードには、名前・番号・成績（0〜100)があり、このプログラムは、学生レコードの追加と削除・番号で指定した学生の成績（数値と文字）の表示・全体の平均点の表示を可能にする。成績の表す文字は以下の通り。
93-100　："A"
90-92　："A-"
87-89　："B+"
83-86　："B"
80-82　："B-"
77-79　："C+"
73-76　："C"
70-72　："C-"
67-69　："D+"
60-66　："D"
0-59　："F"

以前この問題に取り組もうとしたときは、無理矢理学生レコードで成績を表す文字も管理しようとしていた。このアプローチの仕方自体が間違いだろう。成績区分は学校の都合で変更されるかもしれない。この成績の文字表示はプログラムで管理してやるべき。そして、問題文にも書いてあるが「学生レコードで管理するのは名前・番号・成績(点数)の3項目という指示もあった。

そして学生を管理するプログラムをクラスで定義していく作業ですが、問題を整理して実装すべき機能を箇条書きにすると次の4項目だろう。
1) 学生レコードの追加
2) 学生レコードの削除
3) 番号で指定した学生の成績(数値と文字)の表示
4) 全体の平均点の表示

では、実際に私が一生懸命作ったプログラムを見てください。たぶんツッコミどころ満載だと思いますよ。でも、これが今の私の実力なんです(^^;)。プログラマの皆さん、是非コメントお願いします。

素直に学生レコードは構造体(ストラクチャ)で作ってみた。

struct Student {
let name: String
let id: Int
var score: Int
init(name: String, id: Int, score: Int) {
self.name = name
self.id = id
self.score = score
}
}

Student構造体は必ずインスタンス生成時にリアルな値を持たないと意味がないのでイニシャライザーで生成させるパターンにした。空の学生レコードが存在するのはおかしいですよね。

次にStudent構造体を管理するSchoolClassクラスを定義していく。

class SchoolClass {
var classMember = [Student]()

init() {}

convenience init(_ member: Student) {
self.init()
classMember.append(member)
}

/* まずSchoolClassクラスで重要なのは、Student構造体を保持するアレーをプロパティにすることだろう。こうしてやれば増える学生を一元管理できる。そして、プロパティはこれ1つだけ。クラス設計で重要なのはインスタンス生成のためのイニシャライザーですよね。先ほどのStudent構造体と異なり、SchoolClassでは、まだ誰も所属していない空のSchoolClassも存在するだろう。したがってDesignated Initializer(指定イニシャライザー)は空のイニシャライザー宣言にする。しかし、SchoolClassをインスタンス化するときに所属する学生が既にいるのであれば、学生を使ってイニシャライズする方法を用意する。Convenience Initializer(簡易イニシャライザー：この日本語が全然しっくりこないんですけど...)はパラメーターを受け取ってイニシャライズさせている。パラメーター内、(_ member: Student)この中のアンダースコアを加えた理由は、メソッド(関数)のパラメーターのとり方と一致させるためです。初期化ステップと関数では、引数のとり方が違うので間違いやすいと思っているのですが、私だけそう思うのだろうか?　*/

func addMember(member: Student) {
classMember.append(member)
}

/* この関数が実装しなければならない項目(1)の学生レコードの追加メソッドだ。アレーが持ってる標準メソッド「.append」を使って組み込むやり方です。*/

func removeMember(id: Int) -> String {
var message = ""
for (index, person) in enumerate (classMember) {
if person.id == id {
message = "\(person.id)番の\(person.name)は削除されました"
classMember.removeAtIndex(index)
break
}
message = "\(id)の学生は存在しないので削除できませんでした"
}
return message
}

/* 次は項目(2)の削除だが、いきなり少し悩んでしまいました。アレーが持つ標準メソッドとfor-in loopでタップルと組み合わせました。学生番号でアレー内でのレコード位置をどうやって探せばいいのか分からなかったからです。レコードの位置が分からないと削除できないですよね。検索したレコードをアレーの最後のアイテムに移動させて「.removeLast」を使う方法もあるかも。最初はレコードを消すだけのメソッドを作りましたが、実際削除されたかどうか分からないのでメッセージも組み込んだんですが、私のやり方では、メッセージに何度も代入操作が発生してパフォーマンスが落ちますね。*/

func gradingScore(score: Int) -> String {
var grading: String = ""
switch score {
case 93...100:
grading = "A"
case 90...92:
grading = "A-"
case 87...89:
grading = "B+"
case 83...86:
grading = "B"
case 80...82:
grading = "B-"
case 77...79:
grading = "C+"
case 73...76:
grading = "C"
case 70...72:
grading = "C-"
case 67...69:
grading = "D+"
case 60...66:
grading = "D"
default:
grading = "F"
}
return grading
}

/* このメソッドは次のメソッド内で使う関数です。テストの点数を受け取ると成績の文字を返すだけの単純な機能です。次に作った成績(数字と文字)を表示させる関数に最初は組み込んでいましたが、管理しやすいように分離させただけです。*/

func getScoreAndMark(id: Int) -> String {
var scoringMessage: String = ""
for person in classMember {
var searchingStudent = person
var searchingScore = person.score
var searchingId = person.id
if searchingId == id {
var studentMark = gradingScore(person.score)
scoringMessage = "\(searchingId)番の学生のスコアは\(searchingScore)点で成績は\(studentMark)です"
break
}
scoringMessage = "\(id)番の学生は存在しません"
}
return scoringMessage
}

/* 項目(3)の番号で指定した学生の成績(数値と文字)の表示を実現させた関数です。for-in loopを使う方法しか思いつきません。全項目を頭から順番にチェックする方法なのでレコード数が多くなるとパフォーマンスがかなり落ちるでしょう。まだまだ検索のためのアルゴリズムが分かっていないので、これからの課題です。本当に覚えることが多い! まだまだ先は長いけど頑張ります! */

func retrieveAverage() -> String {
var totalScore = 0.0
var averageScore = 0.0
for person in classMember {
totalScore += Double(person.score)
}
averageScore = totalScore / Double (classMember.count)
return "このクラスの平均点は\(averageScore)です"
}
}

/* これが最後の項目(4)全体の平均点の表示で、これは比較的簡単でした。注意すべきことはIntをDoubleにキャスティングしてやらないといけないということぐらいですね。*/

さて、実際の挙動を確かめてみました。

var classA = SchoolClass(Student(name: "Yuji", id: 1, score: 98))
学生「Yuji」が登録された「classA」インスタンスが生成されました。

var classB = SchoolClass()
「classB」は学生の登録されていないSchoolClassです。

classA.addMember(Student(name: "Genki", id: 2, score: 81))
もう一人登録。

classA.addMember(Student(name: "Yuki", id: 3, score: 89))
さらに一人

classA.addMember(Student(name: "Miyuki", id: 4, score: 75))
そして4人登録しました。

println(classA.getScoreAndMark(3))
学籍番号3番の学生の成績は?
「3番の学生のスコアは89点で成績はB+です」
コンソールにちゃんと表示されました。

println(classA.retrieveAverage())
平均点を表示してみましょう。
「このクラスの平均点は85.75です」

classA.removeMember(3)
番号3番の学生を削除しました。コンソールに表示するようにしていないので何も起こりませんが、messageにはきちんと「3番のYukiは削除されました」がで宇入されています。

println(classA.getScoreAndMark(3))
もう既に3番の学生は削除されているのでコンソールに次の表示がされます。
「3番の学生は存在しません」

ということで課題クリア。

アルゴリズムの勉強もしていかないといけないが、またiOS SDKの勉強に戻ります。  

ｚ「Swift Fundamentals: The Language of iOS Development - スイフト：基本」はまだまだ続く。

今日のテーマはサブクラスと関数のオーバーライド。

さあ、私のようにOOPの勉強を3ヶ月もした人間にとって、この内容は難しくないのだが、まだまだOOPのトレーニングができていないので、実践的に使えない。

「オブジェクト指向でなぜつくるのか 第2版」この本に書かれていたクラスの特徴をもう一度説明しよう。

Swiftで遊ぼう！ - 73 オブジェクト指向でなぜつくるのか 第2版で説明しているが、クラスの特徴は３つ。

1.　クラス
2.　継承
3.　ポリモーフィズム(多様性)

この３つだ。これを復習する必要がある。

まず、「クラス」の考え方だが、基本的に重要なのがプロパティはローカル扱いで外には見えず中だけでカプセル化するということ。インスタンスをいくらでも必要なだけ作ることができるのもクラスの特徴である。

そしてこれを「継承」できるのがクラスの重要な機能の一つ。クラスを継承させる時の考え方は、素人の私のような人間が最初に思い浮かべるのが、ベースになるクラスを考え、それを継承させるサブクラスを作っていく流れが自然なような気がする。しかし、実際はベースから考えるのではなく、ここの章でも示しているように、Carクラスを考え、それに似たTruckクラスを作ったとき、共通する部分としてVehicleクラスを作るという考えが自然な流れのようだ。サブクラスが、「継承」という概念を実現したものと考えていいのだろう。これであっているのだろうか？

ベースクラスの抽出という考え方は、少し視点を変えれば、ポリモーフィズムという考え方にもなりますね。いわゆる「共通メインルーチン」を抽出するという考え方です。実は、明日以降に説明する「プロトコール」が、このポリモーフィズムの実装ということになる。Swiftでは「プロトコール」ですが、他の言語で「インターフェイス」と呼ぶようだ。

サブクラスの説明を以下のようにしていた。

class Vehicle {
var maxSpeed: Double
var currentSpeed = 0.0
var make: String
init(maxSpeed: Double, make: String) {
self.maxSpeed = maxSpeed
self.make = make
}
func getSpeed() -> Double {
return maxSpeed
}
func getMake() -> String {
return make
}
func makeNoise() {
}
}

class Car: Vehicle {
override func makeNoise() {
println("Honk")
}
func accelerate() {
println("Accelerating")
}
}

class AMbulance: Vehicle {
override func makeNoise() {
println("WAAAAAHHHHHHH!")
}
}

let aCar = Car(maxSpeed: 75, make: "Jeep")
let anAmbu = AMbulance(maxSpeed: 105, make: "Ambulance Company")

aCar.getSpeed()

aCar.makeNoise()　//Honk
anAmbu.makeNoise() //WAAAAAHHHHHHH!

同じ関数なのに多様性が与えられているということで、この関数「makeNoise()」はプロトコール的な実装のしかただと思います

じゃあ簡単に章末の問題を解こう

Questions for Review - 復習のための質問

1. 親クラスと全く関連性のないサブクラスを持つことが有用性がある。
a) 正しい
b) 間違い
これは当然（b）の間違いですね。

2. サブクラスを適切に宣言するシンタックスは次のどれですか?
a) subclass mySubclass { // subclass code block }
b) subclass mySubclass: myClass { // subclass code block }
c) class mySubclass: myClass { // subclass code block }
d) class mySubcass inherits myClass { // subclass code block }
これは（c）が正解です。

3. オーバーライド（override)を使うと親クラスのメソッドと異なるメソッドとサブクラスに組み込むことができる
a) 正しい
b) 間違い
これは（a)で正しい。

4. オブジェクト指向プログラミングの1つの利点は何ですか?
a) 大きなプログラムの中で組織化され構造化することができる
b) 印象的なイメージを与える
c) 一覧性を与えることで関数を系統立てることができサブクラス化した定数や変数を埋め込むことができる。
d) 何も利点がない
これは(a)ですね。

今日はここまで。


  

「Swift Fundamentals: The Language of iOS Development - スイフト：基本」はまだまだ続く。

Swiftは、関数型プログラミングのようにモダンなプログラミングができることで注目されていますが、今までのプログラミング法(OOP) あっての関数型プログラミングだという話を「オブジェクト指向でなぜつくるのか 第2版」を読んで理解できました。初心者はやっぱりオブジェクトの理解が重要である。

まだこの本のクラスに関する説明を全部読んでいないけど、最初の説明として不十分じゃないかと感じた。メモリーを有効活用するために進化してきたOOPプログラミングの簡単な説明をしないと、なぜメモリーのアドレス値(またの名をポインター値、リファレンス値)を指定して値を扱う必要があるのか理解できないだろうね。必要な時だけ設計図にあたるクラスからインスタンス(実体の値)を生成して扱って、不必要になれば消去(デイニシャライズ)する意味がわからない。

この章の説明で、Dogクラスを例えに出している。普通クラスの説明をするとき、デフォルトイニシャライザーを使って、インスタンス生成時にパラメーターを与えない例えが多いけど、ここでは、クラスの生成の要になるイニシャライザーの説明をして、「init()」を使っているのはいいと思う。しかし、プロパティのネーミングは実際推奨されている方法と異なるのが残念てすね。理由は分かるんですけどね。

この本で説明しているクラス宣言の例文は以下の通りです。

class Dog {
var Name: String
var Breed: String
var Age: Int
init(name: String, breed: String, age: Int) {
Name = name
Breed = breed
Age = age
}
}

既にプログラミングの勉強をしている人は気づいていると思うけど、このクラス宣言はいただけませんよね。変数の名前の付け方が拙いんです。ちょっと勉強をした私ならこれが以下の通りになります。

class Dog {
var name: String
var breed: String
var age: Int
init(name: String, breed: String, age: Int) {
self.name = name
self.breed = breed
self.age = age
}
}

たぶん、この本の著者は「self.」の説明をするのが疎ましく感じたのかもしれません。しかし、実際のコーディングでは理解していないといけないので言及すべきじゃないでしょうか。

まあ、不満に感じながら章末の問題を解く。

Questions for Review - 復習のための質問

1.　プログラムの安価でクラスで何ができますか？
a) 似たようなデータグループを安全な型宣言でまとめることができる
b) 実際に使用するオブジェクトの抽象モデルを作る
c) key-valueのペアを使って情報をリスト化する
d) メモリーから使っていない情報を除去する

2.　適切なクラス宣言は次のどれですか？
a) let myClass:class = {// class code block}
b) class myClass = {// class code block}
c) class myClass {// class code block}
d) class myClass() {// class code block}
また読書を混乱させる問題だろう。答えは(c)ではあるが、ネーミングが間違えている。本当の正解は、「class MyClass { // class code block} 」として、キャメルケースの最初の文字を大文字にするのがクラスのルールですよね。

3.　クラスの中で「init()」は何をしますか？
a) クラスからインスタンス生成時にプロパティを初期化します
b)　クラスが宣言されたときにプロパティを初期化します
c) クラスのすべてのプロパティをデフォルト値にリセットします
d) 可読性のために何もしない
これは当然(a)ですね。

4.　クラスの中で宣言される関数は「メソッド」として知られている
a) 正しい
b)　間違い
これは(a)で正しいです。

今日はここまで。  

The Swift Programming Language本をみていこう。まだクラスと構造体の説明のところ。(実は、この「Swiftで遊ぼう！」の第1回目がClasses and Structuresなんですよね。読み直したら、なんとなく理解できたって感じです(^^;))

クラスと構造体の類似点を前回説明したけど、両者ともプロパティを設定できて、それにアクセスすることができる。「プロパティへのアクセス」のセクションを読んだら理解できたよ。やっぱり、2度目なので注釈の説明も少し理解できるようになっている。注釈は主にObject-Cプログラマ向けの機能の相違点を説明してある。クラスにしろ構造体にしろ、そのプロパティにクラスや構造体を持つことができてアクセスもできる。

struct Resolution {
var width = 0
var height = 0
}

class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}

上記のようなクラスを設計した場合

var someVideoMode = VideoMode()
このようにインスタンスを宣言した後に

someVideoMode.resolution.width = 640
プロパティのプロパティのプロパティに直接アクセスすることが、Swiftでできるけど、Object-Cではできないという説明がされていました。Swiftは非常に自由度が高いんですね。しかし、オブジェクト指向的に考えれば、自由度の高さは、逆に設計の自由度がありすぎて理解しにくいという話にもなりますよね。あえてサブスクリプトを組み込んで、プロパティをprivate設定することでアクセス権限をする方が親切という説明も読みました。まあ、どれだけ理解して使用するかということですね。

構造体のイニシャライザーの説明をもう一度。イニシャライザーはクラス宣言をする時に重要なので構造体のイニシャライザーのルールを忘れてました。

構造体の場合、デフォルトイニシャライザーとメンバーワイズイニシャライザーの2つしかありません。また、メンバーワイズイニシャライザーもあえて定義する必要はなく、自動的に判断してくれるので、上記デフォルトイニシャライザーと組み合わせて

let vga = Resolution(width: 640, height: 480)
勝手にメンバーワイズイニシャライズすることができるけど、

let vga1 = Resolution(width: 640)　// エラー！！！
このようにプロパティ1個だけメンバーワイズイニシャライズすることはできない！  

シンタックスの定義

クラスも構造体も似たようなシンタックスを使って定義する。クラスの場合は「class」で構造体は「struct」をつけて、「{}」の中に定義をいれる。

class SomeClass {
//　クラス定義
}
struct SpmeStructure {
//　構造体定義
}

名前の付け方だた、クラスや構造体は、SomeClassやSomeStructureのように頭文字は大文字にして、与えられるプロパティやメソッドは、「lowerCamelCase」のように頭文字を小文字にすることが慣習的に決められている。

例をあげると次のようになる。

struct Resolution {
var width = 0
var height = 0
}

class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}

ここまで何の問題もなく理解はできているつもり。デフォルトイニシャライザーでイニシャライズされるから、単純明快な例文だろう。「?」のオプショナルの使い方も問題ない。定義するときは、オプショナル扱いなので、この値を再利用する時に注意が必用で、「！」を使って強制アンラップして型をき一致させないといけない。

そして、クラスも構造体も設計図にあたるので、実際離礁するために具体的な値の代入されたインスタンスを使用することにななる。

さらに、クラスと構造体のプロパティは「。」ドット　シンタックスを使ってアクセスすることができる。

実は、正本であるThe Swift Programming Language本、2度目の改訂が9月18日にさえていた！　まさに読み直すのにグッドタイミングだね。明日変更点もみてみよう。  

さて、また「プロおも本」の中断です。というのも、Swiftの文法を忘れているからです。一回読んでいても理解できてないところが多いので、覚えていないシンタックスだらけ。もう一度読み直してみよう。

気になるところから読み直しということで、「クラス(Classses)と構造体(Structures)」から始める。

クラスと構造体、どちらもプロパティとメソッドを燃すことができて、同じような定数、変数、関数のシンタックスを使ってインスタンスを生成する。それに同じシングルファイルで管理することができる。

クラスから派生インスタンスは、オブジェクトと呼ばれていた。しかし、Swiftでは、クラスと構造体の類似性が他の言語より強いので、クラスと構造体どちらでも、派生した値をインスタンスという。

クラスと構造体を比べる

共通点
・値を保持するプロパティを定義できる
・機能性を与えるメソッドを定義できる
・シンタックスを使って値にアクセスするサブスクリプトを定義できる（最初読んだときは、これの重要性が分からなかった、しかし、今はこの利便性が理解できる。直接プロパティにアクセスさせないで、サブスクリプトを使ってアクセスさせることで、保守性を高めている。←これが理解できていれば、私より理解していることになる。この意味が分からなければ、質問してください。)
・初期状態を作るためにイニシャライザーを定義できる
・初期設定で組み込んだ関数を拡張させることができる。
・ある種の特定の機能を提供するプロトコールを適合させらえる（まだプロトコールを完全理解できていない(T_T)）

構造体に無くて、クラスにある機能
・1つのクラスから、その性質を他のクラスに継承ささる事ができる。
・タイプキャストすることで、実行中にクラスインスタンスの型を確認して適合させることができる。
・デイニシャライザーを使って、クラスインスタンスが持っていたメモリー領域を開放させることができる。
・リファレンスカウンティングによって、１つ以上のリファレンスをクラスインスタンスに割り当てられる（いまだに、この意味がさっぱりわからない。どういうことだろう？？？？　ARCに関わることでしょうね)。

さて、読み直していっているが、明らかに初めて読んだ時と理解度が違う。やっぱりオブジェクトプログラミングの基本的な概念が頭に入っているからだろう。当にThe Swift Programming Language本の復習をする時期だな。  

2014年9月25日追記
The Swift Programming Language本の2回目の改訂が9月18日にされたんで、再び読み返している。この記事を書いた時の疑問点は、ちゃんと正本で説明されていたよ。納得できないけど、ルールはルールとして頭にいれないといけないですね。構造型(Strructure型)は基本的に値保持をするので、インスタンスが生成された時点でメモリーが確保される。この場合、例え「var」変数宣言をしたプロパティを持つ構造型を「let」定数値として宣言したらプロパティは定数になってしまうので変更できなくなる。逆にクラス型は、基本的にリファレンスタイプなので、インスタンス宣言した時に保持されたメモリー空間を指定(ポインタ的ですよね)したことを定数宣言しているので、参照される先(プロパティ)に影響は及ばないので、変数宣言さたプロパティならば変更できると言うことだろう。私みたいなオヤジになると、こういう概念が頭にすーっと入ってこないんですよね。でも、何となく理解したということにします。たぶん、忘れてしまうので、3回目の精読時にもう一度チェックしなきゃね。

-----
WWDC2014で発表された新しいプログラミング言語、Swiftが気になる。Xcode6で新たに加わったPlaygroundsを見ていると、おっと、プログラミングに挫折した私でも遊べるんじゃないかと思えてきた！　教科書にあたる"The Swift Pragramming Langage"って本は、iBooks Storeで無料で配られてるじゃないですか！　　英語が読めるのなら、単語数や文法も単純なSwiftは楽勝じゃないかと考えながら読み進めてみたけど、やっぱり今時のモダンプログラミングの概念にやられている。

脱アルゴリズムの関数型プログラミング、なんとなく解るようなわからないような...

Playgraoudsで遊んでみよう。ポインターなんて解らないし、クラスやインスタンスもイマイチ理解できていないけど適当にやってみることにしよう。それがPlaygroundsの利用法だろう。

「The Swift Programming Language」もまだ全て読み切ったわけじゃないけど、適当に読みながらPlaygroundsで実験、実験。

Classes and Structuresにある例文から、

-----
struct Resolution {
var width = 0
var height = 0
}

class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}

let someResolution = Resolution()
let someVideoMode = VideoMode()

println("The width of someResolution is \(someResolution.width)")
println("The width of someVideoMode is \(someVideoMode.resolution.width)")
someVideoMode.resolution.width = 1280
println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
//The width of someVideoMode is now 1280
ここまでではなんとなくわかる。someVideoModeのプロパティにResolutionのプロパティであるwidthが使われている。このクラスはインスタンスになるんで、このwidthのプロパティは新たに作られている(メモリーが振られてる？)ので、上記のsomeVideoMode.resolution.width = 1280とvalueを変更してやることができるということは何となくわかる。

println("The widht of someResolution is now \(someResolution.width)")
//The widht of someResolution is now 0
上のようにオリジナルのstructuresであるsomeResolution.widthは1280にはなっていないで、デフォルトである0のままってのも理解できる。

someResolution.width = 960
とStructuresのvalueを変更してみようとしたけど、assignエラーが出ました！
よく考えると、someResolutionは「let」で宣言しているんで、一度宣言した定数は変更できないんだ。なんて思ったけど、「let」で宣言しているsomeVideoModeはどうして、プロパティを変更できるのかだろうか？？？　　クラスのインスタンスとして定数だけど、プロパティは変数宣言しているんで変更できる？？？

元の宣言で、let someResolution = Resolution()をvar someResolution = Resolution()にしてみる。

var someResolution = Resolution()
println("The widht of someResolution is now \(someResolution.width)")
someResolution.width = 960
println("The width of someResolution is now \(someResolution.width)")
//The widht of someResolution is now 0
//The width of someResolution is now 960
やっぱり！、プロパティを変更できた！　やっぱり定数宣言したStructureは後で変更できないんだ。でもClassの場合は定数宣言しても、プロパティを変更できるというのは、Cインスタンスを生成しているから？？？　なにかあるんだろうけど理解できない。引っかかるが、今は疑問として残しておこう。