￥14,406 税込

ポイント: 144pt (1%) 詳細はこちら

無料配送 6月24日-29日にお届け（7 時間 42 分以内にご注文の場合）
詳細を見る

お届け先を選択

通常5～6日以内に発送します。在庫状況について

￥￥14,406 () 選択したオプションを含めます。最初の月の支払いと選択されたオプションが含まれています。詳細

出荷元

uk_books_and_music

出荷元

uk_books_and_music

販売元

uk_books_and_music

（97379件の評価）

販売元

uk_books_and_music

（97379件の評価）

支払い方法

お客様情報を保護しています

支払い方法

お客様情報を保護しています

Amazonはお客様のセキュリティとプライバシーの保護に全力で取り組んでいます。Amazonの支払いセキュリティシステムは、送信中にお客様の情報を暗号化します。お客様のクレジットカード情報を出品者と共有することはありません。また、お客様の情報を他者に販売することはありません。詳細はこちら

詳細はこちら

すべて見る

Amazonの他の出品者

新品＆中古品 (17)件の出品：￥2,700 + ￥250 配送料

画像はありません

選択したカラーの画像がありません。
カラー：

このビデオを見るには、次をダウンロード Flash Player

著者をフォローする

Introduction To Functional Programming, 2nd Edition (Prentice Hall Series in Computer Science) ペーパーバック – 1998/4/29

英語版 Richard Bird (著)

4.0 12個の評価

すべての形式と版を表示

このページの読み込み中に問題が発生しました。もう一度試してください。

{"desktop_buybox_group_1":[{"displayPrice":"￥14,406","priceAmount":14406.00,"currencySymbol":"￥","integerValue":"14,406","decimalSeparator":null,"fractionalValue":null,"symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"QfB4bnCn3NfeI0yMCH%2F1ry4FF5xAIP31V6N58dQwIlvZEVcieuhpB1Fvs6e26cBYd%2BeusHkfWPm4rBZ66hLTym%2FKtXe64D2cSskH0XDjz1xqQLCeYf8qfO%2Flni50IYtDtdcXkT9%2BS4D%2FZg4F1%2FD2ds2LlMZ%2Bsl86JpU0su4AvU9sog8TIRfObg%3D%3D","locale":"ja-JP","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}]}

購入オプションとあわせ買い

After the success of the first edition of Introduction to Functional Programming, the authors have thoroughly updated and revised this bestselling title. This book is unusual amongst books on functional programming in that it is primarily directed towards the concepts of functional programming, rather than their realization in a specific programming language. The book clearly expounds the construction of functional programs as a process of mathematical calculation, but the mathematics is restricted to that relevant to the actual construction of programs.

この商品に関する問題を報告する

本の長さ

448ページ
言語

英語
出版社

Prentice Hall
発売日

1998/4/29
寸法

17.15 x 1.91 x 23.5 cm
ISBN-10

0134843460
ISBN-13

978-0134843469
すべての詳細を表示

登録情報

出版社 ‏ : ‎ Prentice Hall; Subsequent版 (1998/4/29)
発売日 ‏ : ‎ 1998/4/29
言語 ‏ : ‎ 英語
ペーパーバック ‏ : ‎ 448ページ
ISBN-10 ‏ : ‎ 0134843460
ISBN-13 ‏ : ‎ 978-0134843469
寸法 ‏ : ‎ 17.15 x 1.91 x 23.5 cm

Amazon 売れ筋ランキング: - 314,444位洋書 (洋書の売れ筋ランキングを見る)
- - 584位Introductory & Beginning Programming
- - 67,427位Education & Reference

カスタマーレビュー:
4.0 12個の評価

著者について

著者をフォローして、新作のアップデートや改善されたおすすめを入手してください。

Richard Bird
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.
著者の本をもっと発見したり、よく似た著者を見つけたり、著者のブログを読んだりしましょう
著者ページでもっと見る
Philip Wadler
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.
著者の本をもっと発見したり、よく似た著者を見つけたり、著者のブログを読んだりしましょう
著者ページでもっと見る

カスタマーレビュー

5つのうち4つ

12グローバルレーティング

星1つ

0%

虚偽のレビューは一切容認しません

この商品をレビュー

カスタマーレビューを書く

レビューのソート基準

上位レビュー、対象国：日本

レビューのフィルタリング中に問題が発生しました。後でもう一度試してください。

shelarcy

定番中の定番。関数プログラミングに対する Reference として価値の高い一冊

2005年12月13日に日本でレビュー済み

(関数)プログラミングに対する基礎的な知識を学ばせるということを主眼にして書かれた教科書です。

そのため Miranda を使っていた前著と同様、あくまで説明の道具である Haskell の ASCII しか使えない文字制限をあえて無視して数学的・理論的に望ましい記号を使っていることに代表されるように、Haskell の解説よりもまずプログラミングについての説明を重視しているという個所が所々伺えます。

とはいえ、だからといってこの本よりも別の本を入門に使った方がいいかというと、そうではありません。strictness (正格性)と laziness (遅延性)の話や (Monad Transformer を含め) Monad の解説がかなりしっかりしていますし、参考文献への案内が充実しているので、これを足がかりに勉強するというのも悪くはないと思います。

これを読んで意味の取りにくい場所は、武市先生による訳の素晴らしい前の版の訳書である「関数プログラミング」を参照すれば、比較的すんなりと理解できると思います。
(もちろん、前の版でも扱われている範囲に限ります。訳書が原書に追随してくれるといいのですが……)

10人のお客様がこれが役に立ったと考えています

役に立った

他の国からのトップレビュー

すべてのレビューを日本語に翻訳

Jason McQuinn

Good buy

2018年8月2日にアメリカ合衆国でレビュー済み

Amazonで購入

Book was in great condition when I got it

レビューを日本語に翻訳する

Roy

Five Stars

2015年8月10日に英国でレビュー済み

Amazonで購入

No issues

レビューを日本語に翻訳する

Bücherkeule

Introduction to programming

2010年3月31日にドイツでレビュー済み

Amazonで購入

In recent years functional programming has made it from the nooks of academia into mainstream computing. Well, not quite. The lingo has arrived, and modern scripting languages such as Groovy, Ruby or Python make heavy use of functional constructs. But truly functional languages are as yet at the outskirts of pragmatic or industrial programming. But they are there: Scala is talked of in the Java world, and F# may soon be making more acolytes in the .Net world (and both these languages owe a lot to Haskell).

The present book is a well written introduction to functional programming using Haskell. It is aimed at undergraduate students taking university courses in computer science. Thus the book pursues a twofold purpose: It both introduces Haskell as a language and it demonstrates essential programming constructs such as lists and trees and algorithms operating on such structures. Examples tend to be formal, and applications of Haskell to real-world programming challenges are not even mentioned. The very strong side of the book is its measured and precise explanation of the fundamental programming constructs of Haskell (chiefly the rather difficult notion of a monad which is the Haskell way of introducing interaction in a functional setting). Its lack of examples from real-world applications makes the style and content of the book at times rather sterile. It is a useful companion to a lecture on programming (and as such it is highly recommended), but for somebody with a good background in computer science and experience with real-life IT the book may seem off the practical mark at times. For those much better literature is available by now, see for instance Real World Haskell . The exercises, by the way, tend to rather easy and are mostly aimed at the beginner in programming.

I place much hope in functional programming as a paradigm for writing code in the future. But the way into a functional language is rather steep and requires more of a mathematical mind than any of the other major players on the market (Cobol was easy for anybody with a sufficiently neat mind, Object Orientation took a long while to take on, and I guess that functional programming will have an even harder time). But there is no denying that with the growing complexity of the things we want to do in IT our tools will have to match that complexity. So if you are a student today, here is a book to help you get into the ways of the future.

3人のお客様がこれが役に立ったと考えています

レビューを日本語に翻訳する

noname

A classical text on functional programming

2018年5月13日にドイツでレビュー済み

Amazonで購入

This book is a classical text for learning functional programming. However it is not the easiest one. For those with a bit of a mathematical mindset this book is highly recommended.

レビューを日本語に翻訳する

Roger Costello

Good info, but dense and ignores details

2012年11月4日にアメリカ合衆国でレビュー済み

Amazonで購入

There is a lot of excellent information in this book.

However, it is very dense and the reader should beware that many of the programs in the book don't work. I surmise that they are more intended to show the algorithm rather than the actual Haskell implementation.

In Haskell it is particularly important to pay attention to the details, which is why I give this book only three stars.

Here is an example of a program in the book that does not work.

On page 82 the author Richard Bird provides this sample implementation of the floor function:

floor x = searchFrom 0
where searchFrom = decrease . upper . lower
lower = until (<=x) decrease
upper = until (>x) increase
decrease n = n - 1
increase n = n + 1

The problem with that implementation is that it does not return an Integer value; rather, it returns a decimal (Double) value. Here's an example:

floor (-3.4) -- returns (-4.0)

That is wrong. The specification for floor says that it "maps a value of type Float to a value of type Integer." Clearly it is not producing an Integer result.

I will now explain how to revise floor so that it returns an Integer value.

The heart of the problem is with the until function.

Here is how Richard Bird implements it:

until :: (a -> Bool) -> (a -> a) -> a -> a
until p f y = if p y then y else until p f (f y)

It takes three arguments, p, f, and y. Look at the signature of that function. The type of the third argument, y, dictates the type of the other arguments and the type of the result--whatever type y is, the other arguments must be the same type and the result must be the same type.

Function until is first invoked by function lower:

lower = until (<=x) decrease 0

Here are the three arguments provided to function until:

(1) p is the partial function (<=x), where x is the input to the floor function. Suppose x is this value: x = (-3.4)

(2) f is the function decrease

(3) y is 0

Now you may argue, "Hey, the third argument, y, is 0 and that's an Integer, so clearly the result of function until will be an Integer." However, that is not correct. The type of 0 is ambiguous, it could be an Integer or it could be a Double. This ambiguity can be seen by checking its type using WinGHCi:

:type 0
0 :: Num a => a

The class Num is high up in Haskell's type hierarchy and it represents any number (Integer, Double, etc.). Thus, we cannot determine the type of function until's result just by examining its third argument. The other arguments will determine whether the 0 is an Integer or a Double. Let's examine the first argument:

p is the partial function (<=x), where x = (-3.4)

p compares "some value" against (-3.4). Let's check the type of (-3.4) using WinGHCi:

:type (-3.4)
(-3.4) :: Fractional a => a

The datatype Double falls within the class Fractional. So p compares "some value" against a Double.

Fundamental rule of Haskell: you cannot compare an
Integer against a Double, you can only compare a
Double against a Double.

Recall that p compares "some value" against (-3.4). What is that "some value"? If we examine the body of function until we see that it is the third argument, y, and we know that y = 0. Ah, now we know how Haskell will treat 0: since the 0 is being compared against a Double value Haskell will treat the 0 as a Double. Okay, now that we know the type of y we can plug it into the type signature for function until:

until :: (a -> Bool) -> (a -> a) -> Double -> a

All a's must be of the same type, so the other a's must also be Double:

until :: (Double -> Bool) -> (Double -> Double) -> Double -> Double

Therefore function until will return a Double value. For example:

until (<=x) decrease 0 -- returns (0.0)

The output of function until is assigned to function lower:

lower = until (<=x) decrease

So the result of function lower is a Double value.

The output of lower is then input to upper and the Double datatype propagates through the entire chain of composed functions:

decrease . upper . lower

The result of function floor is therefore a Double value.

Okay, so how do we get floor to return an Integer value? The key is to prevent p in function until from casting the type of y to a Double. Recall function lower:

lower = until (<=x) decrease 0

Notice that p is this partial function:

(<=x)

We must modify p to express, "Hey, compare x against an Integer value that has been cast to a Double value." That is implemented using a Lambda (anonymous) function:

(\a -> (realToFrac a) <= x)

Read that as: For whatever value, a, is provided convert it to a Fractional (Double) value and then compare it to x.

Wow!

So we are telling Haskell that the 0 is not to be treated as a Fractional (Double) value, it is to be treated as a Real (Integer) value.

At last, we can implement function floor and it will return the desired Integer result:

floor x = searchFrom 0
where searchFrom = decrease . upper . lower
lower = until (\a -> (realToFrac a) <= x) decrease
upper = until (\a -> (realToFrac a) > x) increase
decrease n = n - 1
increase n = n + 1

Notice that wherever function until is called (in lower and upper), the first argument, p, is a Lambda (anonymous) function that takes its argument, a, and casts it from a Real (Integer) value to a Fractional (Double) value. Here are a couple examples of using this revised floor function:

floor (-3.4) -- returns (-4)
floor 3.4 -- returns 3

Notice that floor now returns an Integer value, which is what we want.

Here is the signature for floor:

floor :: (Fractional a, Ord a, Real c) => a -> c

Read as: Invoke function floor with a Fractional (Double) value and it will return a Real (Integer) value.

On page 83 Richard Bird shows a second version of function floor that uses a binary search:

floor x = searchFrom (-1, 1)
where searchFrom = fst . middle . cross(lower, upper)
lower = until (<= x) double
upper = until (> x) double
middle = until done improve
done (m, n) = (m + 1 == n)
improve (m, n) = if p <= x then (p, n) else (m, p)
where p = (m + n) div 2

That has multiple problems. First, it is syntactically not a well-formed Haskell program because the div operator (on the last line) must have back ticks ( ` ) surrounding it:

where p = (m + n) `div` 2

Second, the functions lower and upper invoke function until. The first argument to until must be a Lambda function as described above:

lower = until (\m -> (realToFrac m) <= x) double
upper = until (\n -> (realToFrac n) > x) double

Third, the function improve compares p (an Integer) against x (a Double), so p must be cast to a Fractional (Double) value:

improve (m, n) = if (realToFrac p) <= x then (p, n) else (m, p)
where p = (m + n) div 2

With those three changes the function works as desired:

floor x = searchFrom (-1, 1)
where searchFrom = fst . middle . cross(lower, upper)
lower = until (\m -> (realToFrac m) <= x) double
upper = until (\n -> (realToFrac n) > x) double
middle = until done improve
done (m, n) = (m + 1 == n)
improve (m, n) = if (realToFrac p) <= x then (p, n) else (m, p)
where p = (m + n) `div` 2

Here are a couple examples of using the revised floor function:

floor (-3.4) -- returns (-4)
floor 3.4 -- returns 3

Notice that floor now returns an Integer value, which is what we want.

Here is the signature for floor:

floor :: (Fractional a, Ord a, Real c) => a -> c

Read as: Invoke function floor with a Fractional (Double) value and it will return a Real (Integer) value.

22人のお客様がこれが役に立ったと考えています

レビューを日本語に翻訳する

レビューをすべて見る

Amazon Advertising 商品の露出でお客様の関心と反応を引き出す	Audible（オーディブル）「聴く」読書会員なら聴き放題	アマゾンウェブサービス（AWS）クラウドコンピューティングサービス	Amazonアウトレット訳あり商品をお手頃価格で販売

Amazonビジネス（法人購買）請求書払い法人価格・数量割引	AmazonGlobal 65か国/地域以上への海外配送がより簡単に	Shopbop 世界中の厳選されたファッションアイテム

著者をフォローする

Introduction To Functional Programming, 2nd Edition (Prentice Hall Series in Computer Science) ペーパーバック – 1998/4/29

購入オプションとあわせ買い

登録情報

著者について

Richard Bird

Philip Wadler

カスタマーレビュー

この商品をレビュー

上位レビュー、対象国： 日本

レビューのフィルタリング中に問題が発生しました。後でもう一度試してください。

他の国からのトップレビュー

上位レビュー、対象国：日本