Index
A
Arguments
Arithmetic operators
Array.map API
Arrays
access
angle brackets
generic type variables
higher-order functions
SeeHigher-order functions, arrays
JavaScript
Js.Array2
luggage array
operations, JavaScript
push method
standard library functions
B
Belt.Array library
Belt.Array.getExn function
Belt.HashSet
Belt.Int.toString
Belt.List standard library
Belt.Map
Belt.MutableMap
Belt.MutableSet
Belt.MutableStack
Belt.Option standard library module
Belt.Option.flatMap functions
Belt.Option.map functions
Belt.Result module
Belt.Set
Belt standard library
Bindings
creation
external
immutable
mutation
refs
shadowing
tuples
types
values associations
variable let declarations
Blocks
Block scoping
Boolean
C
Chess examples
Command-line arguments
Compile time
Conditionals
console.log function
Constructor
Currying
D
Data structures
Data types
algebraic
arrays/tuples
bindings
chart mapping
complex
composite data types
tuples
variants
functions
integers
maps/sets/lists
options
recursive
simple
traversing
variants
Deserialization
Destructuring
E
enums
Error constructor
Errors
Exception handling
Exceptions
catching
custom exceptions
definition
error handling
errors, results
failwith
MyException
results
string
JavaScript
raising
ReScript
Exhaustiveness
Expressions
F
Filter
First-in first-out (FIFO)
First-order functions
flatMap
Floats
For-loops
Functional programming
Function body
Functions
bindings
body
currying
declaration/calling
definitions
higher-order functions
JavaScript
modules
parameters
partial application
piping
polymorphic functions
pure functions
recursive functions
standard library functions
type annotations
functor
G
Generic collections
Generic Hash Set/Hash Map Keys
getWithDefault function
H
Higher-order functions
arrays
action
filter
generalization
map
pipeline operation
reduce
write loops/update variables
lists
Belt.List.fromArray
Belt.List.keep
Belt.List.map
Belt.List.reduce
drawbacks
immutability
pattern match
processLuggage function
Higher-order programming
I
Immutability
Immutable collections
generic collections
higher-order functions
immutable maps
access
Belt.Map
creation
updation
immutable sets
creation
set operations
updation
lists
luggage example
natural sort
ReScript’s standard library
Impure functions
Integers
int_of_float()
isPawn function
J, K
JavaScript
annotations
@module annotation
bindings
CallJsDemo.res
jsmodule.js
JSON.parse
objects
output
%%raw()
ReScript
exporting values
function
modules
runtime
Js.Array2
Js.Array2.map
Js.Array2.reduce
JSON
validation
w/ No Types
w/ Types
L
Labeled parameters
Last-in first-out (LIFO)
Lists
vs. arrays
data structure
higher-order functions
SeeHigher-order functions, lists
immutability
linked list structure
one-element list
pattern match
prepending, elements
two-element list
wrap elements
Loops
for-loops
syntax
while-loops
M
Manhattan function
Map
Modules
abstraction
Belt
vs. classes
code reuse
data structure
definition
destructuring
extension
files
functions/values
functors
definitions
inputs
MakeMutableStack
modules creation
mutable stacks
MutStack
standard library
Hello.res
key-value pairs
ListMap
ListStack
mapping
members
Myfile.bs.js
names
namespacing
nested
opening
Array.map
Belt.Array
MyModule.MyNestedModule
shadowing
warning
PriorityQueue
size/get function
stack operations
types
Module signatures
abstraction
ImmStack
immutable stack
interface files
ListStack
MyModule
MyStack
uses
Mutable collections
arrays
dicts (dictionaries)
access
creation
JavaScript objects
ReScript
serialization
updation
functional style
HashSet/HashMap
access
advantage
API
creation
generic
luggage example
MutableMap
MutableQueue
MutableSet
mutable stack
ReScript’s standard library
Mutable fields
MutableQueue
Mutable stack
N
Nominal typing
Non-boolean values
Null
O
Objects
creation
declarations
field accesses
JavaScript
JSON
deserializing objects
serializing objects
mutation
printing
vs. records
ReScript
structural typing
Optional fields
Options
P
Partial application
Pattern matching
Performance-sensitive computations
Piping
Polymorphic functions
Polymorphic types
Polymorphic variants
Polymorphism
Positional parameters
Pure functions
ignoring return values
immutability
real-world software
side effects
Purity
push method
Q
Queues
R
Records
creation
declarations
destructuring
fields
JSON
deserialization
serialization
mutable fields
nominal typing
nonextensible
vs.objects
optional field
pattern match
printing
record field accesses
ReScript
tuples
update
vs. variants
Recursion
factorial function
functional style
imperative implementation
logic simplification
loops
recursive implementation
syntax
traversing data types
unrolling
reduce functions
Reduce operation
Reducer function
Referential equality
Refs
ReScript
binding
blocks
block scoping
compiler
compile time/runtime
conditionals
expressions
functional programming
function definition syntax
Loops
objects
pipe operator
primitive types and operators
boolean
integers/floats
string
unit
printing/debugging
recursion
side effects
standard library
static typechecking
switches
type inference
types
value
web app
SeeWeb app
Runtime
S
Semantics
Serialization
Set.fromArray
Shadowing
Standard library functions
Static typechecking
String concatenation
String interpolation
String literals
Strings
Structural equality
Structural typing
Switches
bindings
conditionals
conditions
data types
expression
pattern matching
statement
underscore _
T
Tagged unions
Tail recursion
toString functions
Transform function
Tuples
accessing
arrays
compile time safety benefits
creation
ordered sequence, values
pattern matching
Type annotations
Typechecker
Typechecking
Type inference
U
Unit
Unrolling
V
Variants
complex pattern
constructor
data
declaration
exhaustiveness
options
pattern matching
recursive data types
values representation
W, X, Y, Z
Web app
client
handwritten bindings
client
client bundling
files
package
running, demo
server
write bindings
imported bindings
client
dependencies
npm
server
server
versions
While-loops
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.