Web Development with ReasonML
Pragmatic Bookshelf (Verlag)
978-1-68050-633-4 (ISBN)
ReasonML is a new syntax for OCaml, a battle-tested programming language used in industry for over 20 years. Designed to be familiar to JavaScript programmers, ReasonML code compiles to highly readable JavaScript. With ReasonML, you get OCaml's powerful functional programming features: a strong static type system with an excellent type inference engine, pattern matching, and features for functional programming with immutable variables. ReasonML also allows flexibility with opt-in side effects, mutation, and object-oriented programming. ReasonML hits the sweet spot between the pure theoretical world and the laissez-faire approach of JavaScript.
Start using ReasonML's powerful type system as you learn the essentials of the language: variables and arithmetic operations. Gain expressive power as you write functions with named parameters and currying. Define your own data types, and integrate all these capabilities into a simple web page. Take advantage of ReasonML's functional data structures with map and reduce functions. Discover new ways to write algorithms with ReasonML's recursion support. Interoperate with existing JavaScript libraries with bindings, and write reactive web applications using ReasonML in tandem with React. Reinforce concepts with examples that range from short, tightly focused functions to complete programs, and practice your new skills with exercises in each chapter.
With ReasonML, harness the awesome power of a functional language while retaining the best features of JavaScript to produce concise, fast, type-safe programs.
What You Need:
You'll need to have node.js (version 10.0 or above) and npm (version 5.6 or above). Once you install the bs-platform package and fire up a text editor, you're ready to go. (There are plugins for many popular editors that will make editing easier.)
J. David Eisenberg is a programmer and instructor at Evergreen Valley College in San Jose, California. He is co-author of several books on programming technology (SVG, Elixir, Erlang, and ClojureScript). David's interest in foreign languages has led him to write online tutorials for Korean, Modern Greek, and Russian. He is also a cat person.
Introduction
What Makes ReasonML Special?
What Should You Know?
What’s in This Book?
Acknowledgments
Online Resources
Make Your First ReasonML Project
Running Your First Program
Using Variables and Doing Arithmetic in ReasonML
Working with Types
Doing Conditional Computation
Working with Strings
It’s Your Turn
Summing Up
Writing Functions
Defining Functions
Using Labeled Parameters
Providing Default Values for Labeled Parameters
Shortening Code with refmt
Specifying Parameter Types
Writing Functions without Parameters or Return Values
Currying: Handling One Argument at a Time
Currying and Labeled Parameters
It’s Your Turn
Summing Up
Creating Your Own Data Types
Renaming a Data Type
Creating Variant Data Types
Using Variant Data Types
Creating Variant Data Types with Parameters
It’s Your Turn
Using the option Type
Working with option Values
Working with Belt.Option
Using Pipe First
It’s Your Turn
Getting Another Perspective
Summing Up
Interacting with Web Pages
Creating an Example Web Page
Setting Up the Project
Accessing the DOM
Building the Web Bundle
Completing the Calculation
Getting a Value
It’s Your Turn
Reviewing DOM Functions
Summing Up
Using Collections
Accessing Functions in Other Files
Grouping Heterogeneous Data with Tuples
Using Lists
Manipulating Lists with Belt.List
Using map, keep, and reduce with Lists
Interlude: Displaying Lists
Using Arrays
Using map, keep, and reduce with Arrays
Putting Arrays to Work
It’s Your Turn
Summing Up
Repeating with Recursion
Defining Recursion
Analyzing a Recursive Algorithm
Writing Recursive Functions
Interlude: Measuring Performance
Understanding Tail Recursion
Practicing More Recursion
Using Recursion with Lists
It’s Your Turn
Summing Up
Structuring Data with Records and Modules
Specifying Records
Accessing and Updating Records
Creating Modules
Creating Interface Files for Modules
Putting Modules to Work
It’s Your Turn
Summing Up
Connecting to JavaScript
Adding Raw JavaScript
Binding to Existing Functions
Interoperating with Data Types
Interoperating with Objects
It’s Your Turn
Working with JSON
Setting Up the Server
Implementing the Client
It’s Your Turn
Summing Up
Making Applications with Reason/React
Viewing React from 20,000 Meters
Starting a ReasonReact Project
Investigating the Sample Project
Creating a More Complex Stateless Component
It’s Your Turn
Using Stateful Components
Putting Components Together
It’s Your Turn
Adding Side Effects with Storage
It’s Your Turn
Summing Up
Understanding the ReasonML Ecosystem
In the Beginning was OCaml
Enter ReasonML
A Non-Unified Ecosystem
Summing Up
Miscellaneous Topics
Switching to fun
Using open
Using Belt.Map.update
Dangerous Interop
Hiding Type Information
| Erscheinungsdatum | 09.04.2019 |
|---|---|
| Verlagsort | Raleigh |
| Sprache | englisch |
| Maße | 190 x 233 mm |
| Gewicht | 404 g |
| Einbandart | kartoniert |
| Themenwelt | Informatik ► Office Programme ► Outlook |
| Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge | |
| Informatik ► Software Entwicklung ► SOA / Web Services | |
| Informatik ► Web / Internet ► JavaScript | |
| Schlagworte | Funktionales Programmieren • JavaScript • Programmieren • Webentwicklung |
| ISBN-10 | 1-68050-633-1 / 1680506331 |
| ISBN-13 | 978-1-68050-633-4 / 9781680506334 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
