Holdings: Real world Haskell :: THWS Bibkatalog

Real world Haskell:

Saved in:

Bibliographic Details
Main Authors:	O'Sullivan, Bryan (Author), Goerzen, John (Author), Stewart, Donald Bruce (Author)
Format:	Book
Language:	English
Published:	Beijing [u.a.] O'Reilly 2009
Edition:	1. ed.
Subjects:	HASKELL
Online Access:	Inhaltsverzeichnis
Physical Description:	XXXVIII, 670 S.
ISBN:	9780596514983

Staff View

MARC


LEADER	00000nam a2200000 c 4500
001	BV035202176
003	DE-604
005	20170328
007	t
008	081208s2009 \|\|\|\| 00\|\|\| eng d
015			\|a 08,N36,0057 \|2 dnb
016	7		\|a 990036448 \|2 DE-101
020			\|a 9780596514983 \|c : EUR 48.00 (freier Pr.) \|9 978-0-596-51498-3
024	3		\|a 9780596514983
035			\|a (OCoLC)601764033
035			\|a (DE-599)DNB990036448
040			\|a DE-604 \|b ger \|e rakddb
041	0		\|a eng
049			\|a DE-92 \|a DE-739 \|a DE-29T \|a DE-703 \|a DE-473 \|a DE-634 \|a DE-859 \|a DE-19 \|a DE-11 \|a DE-91G \|a DE-Aug4 \|a DE-188 \|a DE-573
082	0		\|a 005.133 \|2 22
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a 004 \|2 sdnb
084			\|a DAT 362f \|2 stub
100	1		\|a O'Sullivan, Bryan \|e Verfasser \|0 (DE-588)1044499230 \|4 aut
245	1	0	\|a Real world Haskell \|c Bryan O'Sullivan, John Goerzen, and Don Stewart
250			\|a 1. ed.
264		1	\|a Beijing [u.a.] \|b O'Reilly \|c 2009
300			\|a XXXVIII, 670 S.
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
650	0	7	\|a HASKELL \|0 (DE-588)4318275-6 \|2 gnd \|9 rswk-swf
689	0	0	\|a HASKELL \|0 (DE-588)4318275-6 \|D s
689	0		\|5 DE-604
700	1		\|a Goerzen, John \|e Verfasser \|0 (DE-588)13067835X \|4 aut
700	1		\|a Stewart, Donald Bruce \|e Verfasser \|0 (DE-588)138118574 \|4 aut
856	4	2	\|m Digitalisierung UB Passau \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=017008615&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
999			\|a oai:aleph.bib-bvb.de:BVB01-017008615

Record in the Search Index

_version_	1804138455883579392
adam_text	Table of Contents Preface ...................................................................xxiii 1. Getting Started .........................................................1 Your Haskell Environment 1 Getting Started with ghci, the Interpreter 2 Basic Interaction: Using ghci as a Calculator 3 Simple Arithmetic 3 An Arithmetic Quirk: Writing Negative Numbers 4 Boolean Logic, Operators, and Value Comparisons 5 Operator Precedence and Associativity 7 Undefined Values, and Introducing Variables 8 Dealing with Precedence and Associativity Rules 8 Command-Line Editing in ghci 9 Lists 9 Operators on Lists 11 Strings and Characters 11 First Steps with Types 12 A Simple Program 15 2. Types and Functions ....................................................17 Why Care About Types? 17 Haskelľs Type System 18 Strong Types 18 Static Types 19 Type Inference 20 What to Expect from the Type System 20 Some Common Basic Types 21 Function Application 22 Useful Composite Data Types: Lists and Tuples 23 Functions over Lists and Tuples 25 Passing an Expression to a Function 26 Function Types and Purity 27 Haskell Source Files, and Writing Simple Functions 27 Just What Is a Variable, Anyway? 28 Conditional Evaluation 29 Understanding Evaluation by Example 32 Lazy Evaluation 32 A More Involved Example 33 Recursion 34 Ending the Recursion 35 Returning from the Recursion 35 What Have We Learned? 36 Polymorphism in Haskell 36 Reasoning About Polymorphic Functions 38 Further Reading 38 The Type of a Function of More Than One Argument 38 Why the Fuss over Purity? 39 Conclusion 40 Definiria TvDes Streamlinina Functions ............................ ....... 41 Defining а New Data Type 41 Naming Types and Values 43 Type Synonyms 43 Algebraic Data Types 44 Tuples, Algebraic Data Types, and When to Use Each 45 Analogues to Algebraic Data Types in Other Languages 47 Pattern Matching 50 Construction and Deconstruction 51 Further Adventures 52 Variable Naming in Patterns 53 The Wild Card Pattern 53 Exhaustive Patterns and Wild Cards 54 Record Syntax 55 Parameterized Types 57 Recursive Types 58 Reporting Errors 60 A More Controlled Approach 61 Introducing Local Variables 61 Shadowing 62 The where Clause 63 Local Functions, Global Variables 63 The Offside Rule and Whitespace in an Expression 64 A Note About Tabs Versus Spaces 66 The Offside Rule Is Not Mandatory 66 The case Expression 66 Common Beginner Mistakes with Patterns 67 Incorrectly Matching Against a Variable 67 Incorrectly Trying to Compare for Equality 68 Conditional Evaluation with Guards 68 4. Functional Programming ................................................71 Thinking in Haskell 71 A Simple Command-Line Framework 71 Warming Up: Portably Splitting Lines of Text 72 A Line-Ending Conversion Program 75 Infix Functions 76 Working with Lists 77 Basic List Manipulation 78 Safely and Sanely Working with Crashy Functions 79 Partial and Total Functions 79 More Simple List Manipulations 80 Working with Sublists 81 Searching Lists 82 Working with Several Lists at Once 83 Special String-Handling Functions 84 How to Think About Loops 84 Explicit Recursion 85 Transforming Every Piece of Input 87 Mapping over a List 88 Selecting Pieces of Input 90 Computing One Answer over a Collection 90 The Left Fold 92 Why Use Folds, Maps, and Filters? 93 Folding from the Right 94 Left Folds, Laziness, and Space Leaks 96 Further Reading 99 Anonymous (lambda) Functions 99 Partial Function Application and Currying 100 Sections 102 As-patterns 103 Code Reuse Through Composition 104 Use Your Head Wisely 107 Tips for Writing Readable Code 107 Space Leaks and Strict Evaluation 108 Avoiding Space Leaks with seq 108 Learning to Use seq 109 5. Writing a Library: Working with JSON Data ................................111 A Whirlwind Tour of JSON 111 Representing JSON Data in Haskell 111 The Anatomy of a Haskell Module 113 Compiling Haskell Source 114 Generating a Haskell Program and Importing Modules 114 Printing JSON Data 115 Type Inference Is a Double-Edged Sword 117 A More General Look at Rendering 118 Developing Haskell Code Without Going Nuts 119 Pretty Printing a String 120 Arrays and Objects, and the Module Header 122 Writing a Module Header 123 Fleshing Out the Pretty-Printing Library 124 Compact Rendering 127 True Pretty Printing 128 Following the Pretty Printer 129 Creating a Package 131 Writing a Package Description 131 GHC s Package Manager 133 Setting Up, Building, and Installing 133 Practical Pointers and Further Reading 134 6. Using Typeclasses .....................................................135 The Need for Typeclasses 135 What Are Typeclasses? 136 Declaring Typeclass Instances 139 Important Built-in Typeclasses 139 Show 139 Read 141 Serialization with read and show 143 Numeric Types 144 Equality, Ordering, and Comparisons 148 Automatic Derivation 148 Typeclasses at Work: Making JSON Easier to Use 149 More Helpful Errors 151 Making an Instance with a Type Synonym 151 Living in an Open World 152 When Do Overlapping Instances Cause Problems? 153 Relaxing Some Restrictions on Typeclasses 154 How Does Show Work for Strings? 155 How to Give a Type a New Identity 155 Differences Between Data and Newtype Declarations 157 Summary: The Three Ways of Naming Types 158 JSON Typeclasses Without Overlapping Instances 159 The Dreaded Monomorphism Restriction 162 Conclusion 163 7. I/O ................................................................. 165 Classic I/O in Haskell 165 Pure Versus I/O 168 Why Purity Matters 169 Working with Files and Handles 169 More on openFile 171 Closing Handles 172 Seek and Tell 172 Standard Input, Output, and Error 173 Deleting and Renaming Files 174 Temporary Files 174 Extended Example: Functional I/O and Temporary Files 175 Lazy I/O 178 hGetContents 178 readFile and writeFile 180 A Word on Lazy Output 181 interact 181 The IO Monad 183 Actions 183 Sequencing 186 The True Nature of Return 187 Is Haskell Really Imperative? 188 Side Effects with Lazy I/O 188 Buffering 189 Buffering Modes 189 Flushing The Buffer 190 Reading Command-Line Arguments 190 Environment Variables 191 8. Efficient File Processing, Regular Expressions, and Filename Matching .........193 Efficient File Processing 193 Binary I/O and Qualified Imports 194 Text I/O , ■ 195 Filename Matching 197 Regular Expressions in Haskell 198 The Many Types of Result 198 More About Regular Expressions 200 Mixing and Matching String Types 200 Other Things You Should Know 201 Translating a glob Pattern into a Regular Expression 202 An important Aside: Writing Lazy Functions 205 Making Use of Our Pattern Matcher 206 Handling Errors Through API Design 210 Putting Our Code to Work 211 9. 1/0 Case Study: A Library for Searching the Filesystem .......................213 The find Command 213 Starting Simple: Recursively Listing a Directory 213 Revisiting Anonymous and Named Functions 214 Why Provide Both mapM and forM? 215 A Naive Finding Function 215 Predicates: From Poverty to Riches, While Remaining Pure 217 Sizing a File Safely 219 The Acquire-Use-Release Cycle 221 A Domain-Specific Language for Predicates 221 Avoiding Boilerplate with Lifting 223 Gluing Predicates Together 224 Defining and Using New Operators 225 Controlling Traversal 226 Density, Readability, and the Learning Process 228 Another Way of Looking at Traversal 229 Useful Coding Guidelines 232 Common Layout Styles 233 10. Code Case Study: Parsing a Binary Data Format ............................235 Grayscale Files 235 Parsing a Raw PGM File 236 Getting Rid of Boilerplate Code 238 Implicit State 239 The Identity Parser 240 Record Syntax, Updates, and Pattern Matching 241 A More Interesting Parser 242 Obtaining and Modifying the Parse State 242 Reporting Parse Errors 243 Chaining Parsers Together 243 Introducing Functors 244 Constraints on Type Definitions Are Bad 247 Infix Use of fmap 248 Flexible Instances 248 Thinking More About Functors · 249 Writing a Functor Instance for Parse 250 Using Functors for Parsing 251 Rewriting Our PGM Parser 252 Future Directions 254 11. Testing and Quality Assurance .......................................... 255 QuickCheck: Type-Based Testing 256 Testing for Properties 257 Testing Against a Model 259 Testing Case Study: Specifying a Pretty Printer 259 Generating Test Data 259 Testing Document Construction 262 Using Lists as a Model 263 Putting It All Together 264 Measuring Test Coverage with HPC 265 12. Barcode Recognition .................................................. 269 A Little Bit About Barcodes 269 ΕΑΝ- 13 Encoding 270 Introducing Arrays 270 Arrays and Laziness 273 Folding over Arrays ■ 273 Modifying Array Elements 274 Encoding an ΕΑΝ- 13 Barcode 275 Constraints on Our Decoder 275 Divide and Conquer 276 Turning a Color Image into Something Tractable 278 Parsing a Color Image 278 Grayscale Conversion 279 Grayscale to Binary and Type Safety 279 What Have We Done to Our Image? 280 Finding Matching Digits 282 Run Length Encoding 282 Scaling Run Lengths, and Finding Approximate Matches 283 List Comprehensions 284 Remembering a Match s Parity 285 Chunking a List 287 Generating a List of Candidate Digits 287 Life Without Arrays or Hash Tables 288 A Forest of Solutions 288 A Brief Introduction to Maps 289 Further Reading 292 Turning Digit Soup into an Answer 292 Solving for Check Digits in Parallel 292 Completing the Solution Map with the First Digit 294 Finding the Correct Sequence 295 Working with Row Data 295 Pulling It All Together 296 A Few Comments on Development Style 297 13. Data Structures .......................................................299 Association Lists 299 Maps 301 Functions Are Data, Too 303 Extended Example: /etc/passwd 304 Extended Example: Numeric Types 307 First Steps 309 Completed Code 311 Taking Advantage of Functions as Data 317 Turning Difference Lists into a Proper Library 318 Lists, Difference Lists, and Monoids 320 General-Purpose Sequences 322 14. Monads ............................................................. 325 325 Revisiting Earlier Code Examples 325 Maybe Chaining 325 Implicit State 326 Looking for Shared Patterns 327 The Monad Typeclass 329 And Now, a Jargon Moment 330 Using a New Monad: Show Your Work! 331 Information Hiding 331 Controlled Escape 332 Leaving a Trace 332 Using the Logger Monad 333 Mixing Pure and Monadic Code 334 Putting a Few Misconceptions to Rest 336 Building the Logger Monad 336 Sequential Logging, Not Sequential Evaluation 337 The Writer Monad 337 The Maybe Monad 338 Executing the Maybe Monad 338 Maybe at Work, and Good API Design 338 The List Monad 340 Understanding the List Monad 342 Putting the List Monad to Work 343 Desugaring of do Blocks 344 Monads as a Programmable Semicolon 345 Why Go Sugar-Free? 346 The State Monad 346 Almost a State Monad 347 Reading and Modifying the State 348 Will the Real State Monad Please Stand Up? 348 Using the State Monad: Generating Random Values 349 A First Attempt at Purity 350 Random Values in the State Monad 351 Running the State Monad 352 What About a Bit More State? 352 Monads and Functors 354 Another Way of Looking at Monads 354 The Monad Laws and Good Coding Style 355 15. Programming with Monads ............................................ 359 Golfing Practice: Association Lists 359 Generalized Lifting 360 Looking for Alternatives 362 The Name mplus Does Not Imply Addition 364 Rules for Working with MonadPlus 364 Failing Safely with MonadPlus 364 Adventures in Hiding the Plumbing 365 Supplying Random Numbers 368 Another Round of Golf 369 Separating Interface from Implementation 369 Multiparameter Typeclasses 370 Functional Dependencies 370 Rounding Out Our Module 371 Programming to a Monad s Interface 372 The Reader Monad 373 A Return to Automated Deriving 374 Hiding the IO Monad 375 Using a newtype 376 Designing for Unexpected Uses 377 Using Typeclasses 378 Isolation and Testing 379 The Writer Monad and Lists 380 Arbitrary I/O Revisited 381 16. Using Parsec ......................................................... 383 First Steps with Parsec: Simple CSV Parsing 383 The sepBy and endBy Combinators 386 Choices and Errors 387 Lookahead 389 Error Handling 390 Extended Example: Full CSV Parser 391 Parsec and MonadPlus 393 Parsing a URL-Encoded Query String 393 Supplanting Regular Expressions for Casual Parsing 395 Parsing Without Variables 395 Applicative Functors for Parsing 395 Applicative Parsing by Example 396 Parsing JSON Data 398 Parsing a HTTP Request 401 Backtracking and Its Discontents 402 Parsing Headers 402 17. Interfacing with C: The FFI ..............................................405 Foreign Language Bindings: The Basics 406 Be Careful of Side Effects 407 A High-Level Wrapper 408 Regular Expressions for Haskell: A Binding for PCRE 409 Simple Tasks: Using the С Preprocessor 410 Binding Haskell to С with hsc2hs 411 Adding Type Safety to PCRE 411 Binding to Constants 412 Automating the Binding 413 Passing String Data Between Haskell and С 414 Typed Pointers 416 Memory Management: Let the Garbage Collector Do the Work 417 A High-Level Interface: Marshaling Data 418 Marshaling ByteStrings 419 Allocating Local С Data: The Storable Class 419 Putting It All Together 420 Matching on Strings 422 Extracting Information About the Pattern 423 Pattern Matching with Substrings 424 The Real Deal: Compiling and Matching Regular Expressions 426 18. Monad Transformers .................................................. 429 Motivation: Boilerplate Avoidance 429 A Simple Monad Transformer Example 430 Common Patterns in Monads and Monad Transformers , 431 Stacking Multiple Monad Transformers 433 Hiding Our Work 435 Moving Down the Stack 436 When Explicit Lifting Is Necessary 437 Understanding Monad Transformers by Building One 438 Creating a Monad Transformer 439 More Typeclass Instances 440 Replacing the Parse Type with a Monad Stack 440 Transformer Stacking Order Is Important 441 Putting Monads and Monad Transformers into Perspective 443 Interference with Pure Code 443 Overdetermined Ordering 444 Runtime Overhead 444 Unwieldy Interfaces 444 Pulling It All Together 445 19. Error Handling ....................................................... 447 Error Handling with Data Types 447 Use of Maybe 448 Use of Either 452 Exceptions 454 First Steps with Exceptions 454 Laziness and Exception Handling 455 Using handle 456 Selective Handling of Exceptions 456 I/O Exceptions 457 Throwing Exceptions 459 Dynamic Exceptions 459 Error Handling in Monads 462 A Tiny Parsing Framework 463 20. Systems Programming in Haskell ........................................467 Running External Programs 467 1 Directory and File Information 468 Program Termination 469 Dates and Times 470 ClockTime and CalendarTime 470 File Modification Times 475 Extended Example: Piping 476 Using Pipes for Redirection 477 Better Piping 483 Final Words on Pipes 491 21. Using Databases ......................................................493 Overview of HDBC 493 Installing HDBC and Drivers 494 Connecting to Databases 495 Transactions 495 Simple Queries 496 SqlValue 497 Query Parameters 497 Prepared Statements 498 Reading Results 499 Reading with Statements 501 Lazy Reading 501 Database Metadata 502 Error Handling 503 22. Extended Example: Web Client Programming ............................. 505 Basic Types 506 The Database 506 The Parser 510 Downloading 513 Main Program 515 23. GUI Programming with gtk2hs ..........................................517 Installing gtk2hs 517 Overview of the GTK+ Stack 517 User Interface Design with Glade 518 Glade Concepts 518 Event-Driven Programming 519 Initializing the GUI 520 The Add Podcast Window 524 Long-Running Tasks 525 Using Cabal 528 24. Concurrent and Multicore Programming ..................................531 Defining Concurrency and Parallelism 531 Concurrent Programming with Threads 532 Threads Are Nondeterministic 532 Hiding Latency 532 Simple Communication Between Threads 533 The Main Thread and Waiting for Other Threads 534 Safely Modifying an MVar 536 Safe Resource Management: A Good Idea, and Easy Besides 536 Finding the Status of a Thread 537 Writing Tighter Code 538 Communicating over Channels 539 Useful Things to Know About 539 MVar and Chan Are Nonstrict 539 Chan Is Unbounded 540 Shared-State Concurrency Is Still Hard 540 Deadlock 541 Starvation 541 Is There Any Hope? 542 Using Multiple Cores with GHC 542 Runtime Options 543 Finding the Number of Available Cores from Haskell 543 Choosing the Right Runtime 544 Parallel Programming in Haskell 544 Normal Form and Head Normal Form 545 Sequential Sorting 545 Transforming Our Code into Parallel Code 545 Knowing What to Evaluate in Parallel 546 What Promises Does par Make? 547 Running Our Code and Measuring Performance 547 Tuning for Performance 550 Parallel Strategies and MapReduce 551 Separating Algorithm from Evaluation 552 Separating Algorithm from Strategy 554 Writing a Simple MapReduce Definition 554 MapReduce and Strategies 555 Sizing Work Appropriately . 555 Efficiently Finding Line-Aligned Chunks 557 Counting Lines 558 Finding the Most Popular URLs 559 Conclusions 560 25. Profiling and Optimization ............................................. 561 Profiling Haskell Programs 561 Collecting Runtime Statistics 562 Time Profiling 563 Space Profiling 566 Controlling Evaluation 570 Strictness and Tail Recursion 571 Adding Strictness 572 Understanding Core 575 Advanced Techniques: Fusion 578 Tuning the Generated Assembly 579 Conclusions 580 26. Advanced Library Design: Building a Bloom Filter.......................... 581 Introducing the Bloom Filter 581 Use Cases and Package Layout 582 Basic Design 583 Unboxing, Lifting, and Bottom 583 The ST Monad 584 Designing an API for Qualified Import 585 Creating a Mutable Bloom Filter 586 The Immutable API 587 Creating a Friendly Interface 588 Re-Exporting Names for Convenience 589 Hashing Values 589 Turning Two Hashes into Many 593 Implementing the Easy Creation Function 593 Creating a Cabal Package 595 Dealing with Different Build Setups 596 Compilation Options and Interfacing to С 598 Testing with QuickCheck 599 Polymorphic Testing 600 Writing Arbitrary Instances for ByteStrings 601 Are Suggested Sizes Correct? 602 Performance Analysis and Tuning 604 Profile-Driven Performance Tuning 605 27. Sockets and Syslog ....................................................611 Basic Networking 611 Communicating with UDP 611 UDP Client Example: syslog 612 UDP Syslog Server 615 Communicating with TCP 616 Handling Multiple TCP Streams 616 TCP Syslog Server 617 TCP Syslog Client 619 28. Software Transactional Memory .........................................623 The Basics 623 Some Simple Examples 624 STM and Safety 626 Retrying a Transaction 626 What Happens When We Retry? 628 Choosing Between Alternatives 628 Using Higher Order Code with Transactions 628 I/O and STM 629 Communication Between Threads 630 A Concurrent Web Link Checker 631 Checking a Link 633 Worker Threads 634 Finding Links 635 Command-Line Parsing 636 Pattern Guards 637 Practical Aspects of STM 638 Getting Comfortable with Giving Up Control 638 Using Invariants 639 A. Installing GHCand Haskell Libraries ......................................641 B. Characters, Strings, and Escaping Rules ...................................649 Index .....................................................................655
any_adam_object	1
author	O'Sullivan, Bryan Goerzen, John Stewart, Donald Bruce
author_GND	(DE-588)1044499230 (DE-588)13067835X (DE-588)138118574
author_facet	O'Sullivan, Bryan Goerzen, John Stewart, Donald Bruce
author_role	aut aut aut
author_sort	O'Sullivan, Bryan
author_variant	b o bo j g jg d b s db dbs
building	Verbundindex
bvnumber	BV035202176
classification_rvk	ST 250
classification_tum	DAT 362f
ctrlnum	(OCoLC)601764033 (DE-599)DNB990036448
dewey-full	005.133
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.133
dewey-search	005.133
dewey-sort	15.133
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
edition	1. ed.
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>01627nam a2200421 c 4500</leader><controlfield tag="001">BV035202176</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20170328 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">081208s2009 \|\|\|\| 00\|\|\| eng d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">08,N36,0057</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">990036448</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9780596514983</subfield><subfield code="c">: EUR 48.00 (freier Pr.)</subfield><subfield code="9">978-0-596-51498-3</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9780596514983</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)601764033</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB990036448</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rakddb</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-92</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-703</subfield><subfield code="a">DE-473</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-188</subfield><subfield code="a">DE-573</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">22</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 362f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">O'Sullivan, Bryan</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)1044499230</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Real world Haskell</subfield><subfield code="c">Bryan O'Sullivan, John Goerzen, and Don Stewart</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">1. ed.</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Beijing [u.a.]</subfield><subfield code="b">O'Reilly</subfield><subfield code="c">2009</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XXXVIII, 670 S.</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">HASKELL</subfield><subfield code="0">(DE-588)4318275-6</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">HASKELL</subfield><subfield code="0">(DE-588)4318275-6</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Goerzen, John</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)13067835X</subfield><subfield code="4">aut</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Stewart, Donald Bruce</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)138118574</subfield><subfield code="4">aut</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=017008615&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-017008615</subfield></datafield></record></collection>
id	DE-604.BV035202176
illustrated	Not Illustrated
indexdate	2024-07-09T21:28:28Z
institution	BVB
isbn	9780596514983
language	English
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-017008615
oclc_num	601764033
open_access_boolean
owner	DE-92 DE-739 DE-29T DE-703 DE-473 DE-BY-UBG DE-634 DE-859 DE-19 DE-BY-UBM DE-11 DE-91G DE-BY-TUM DE-Aug4 DE-188 DE-573
owner_facet	DE-92 DE-739 DE-29T DE-703 DE-473 DE-BY-UBG DE-634 DE-859 DE-19 DE-BY-UBM DE-11 DE-91G DE-BY-TUM DE-Aug4 DE-188 DE-573
physical	XXXVIII, 670 S.
publishDate	2009
publishDateSearch	2009
publishDateSort	2009
publisher	O'Reilly
record_format	marc
spelling	O'Sullivan, Bryan Verfasser (DE-588)1044499230 aut Real world Haskell Bryan O'Sullivan, John Goerzen, and Don Stewart 1. ed. Beijing [u.a.] O'Reilly 2009 XXXVIII, 670 S. txt rdacontent n rdamedia nc rdacarrier HASKELL (DE-588)4318275-6 gnd rswk-swf HASKELL (DE-588)4318275-6 s DE-604 Goerzen, John Verfasser (DE-588)13067835X aut Stewart, Donald Bruce Verfasser (DE-588)138118574 aut Digitalisierung UB Passau application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=017008615&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis
spellingShingle	O'Sullivan, Bryan Goerzen, John Stewart, Donald Bruce Real world Haskell HASKELL (DE-588)4318275-6 gnd
subject_GND	(DE-588)4318275-6
title	Real world Haskell
title_auth	Real world Haskell
title_exact_search	Real world Haskell
title_full	Real world Haskell Bryan O'Sullivan, John Goerzen, and Don Stewart
title_fullStr	Real world Haskell Bryan O'Sullivan, John Goerzen, and Don Stewart
title_full_unstemmed	Real world Haskell Bryan O'Sullivan, John Goerzen, and Don Stewart
title_short	Real world Haskell
title_sort	real world haskell
topic	HASKELL (DE-588)4318275-6 gnd
topic_facet	HASKELL
url	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=017008615&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT osullivanbryan realworldhaskell AT goerzenjohn realworldhaskell AT stewartdonaldbruce realworldhaskell

Holdings

There is no print copy available.

Interlibrary loan Place Request Caution: Not in THWS collection! Indexes

MARC

Record in the Search Index

There is no print copy available.

Similar Items