思维导图备注

F# for Fun and Profit eBook
首页 白天 夜间 BookChat 小程序 小程序 阅读
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

Examples and Walkthroughs

浏览 526 扫码 分享 2018-04-28 05:54:36

  • Worked example: Designing for correctness
  • Worked example: A stack based calculator
  • Worked example: Parsing command line arguments
  • Worked example: Roman numerals
  • Commentary on ‘Roman Numerals Kata with Commentary’
  • Calculator Walkthrough: Part 1
  • Enterprise Tic-Tac-Toe
  • Writing a JSON parser from scratch

上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • F# for Fun and Profit eBook
  • Getting started
    • Contents of the book
    • “Why use F#?” in one page
    • Installing and using F#
    • Learning F#
    • Troubleshooting F#
    • Low-risk ways to use F# at work
      • Twenty six low-risk ways to use F# at work
      • Using F# for development and devops scripts
      • Using F# for testing
      • Using F# for database related tasks
      • Other interesting ways of using F# at work
  • The “Why use F#?” Series
    • Introduction to the ‘Why use F#’ series
    • F# syntax in 60 seconds
    • Comparing F# with C#: A simple sum
    • Comparing F# with C#: Sorting
    • Comparing F# with C#: Downloading a web page
    • Four Key Concepts
    • Conciseness
    • Type inference
    • Low overhead type definitions
    • Using functions to extract boilerplate code
    • Using functions as building blocks
    • Pattern matching for conciseness
    • Convenience
    • Out-of-the-box behavior for types
    • Functions as interfaces
    • Partial Application
    • Active patterns
    • Correctness
    • Immutability
    • Exhaustive pattern matching
    • Using the type system to ensure correct code
    • Concurrency
    • Asynchronous programming
    • Messages and Agents
    • Functional Reactive Programming
    • Completeness
    • Seamless interoperation with .NET libraries
    • Anything C# can do…
    • Why use F#: Conclusion
  • The “Thinking Functionally” Series
    • Thinking Functionally: Introduction
    • Mathematical functions
    • Function Values and Simple Values
    • How types work with functions
    • Currying
    • Partial application
    • Function associativity and composition
    • Defining functions
    • Function signatures
    • Organizing functions
    • Attaching functions to types
  • The “Expressions and syntax” Series
    • Expressions and syntax: Introduction
    • Expressions vs. statements
    • Overview of F# expressions
    • Binding with let, use, and do
    • F# syntax: indentation and verbosity
    • Parameter and value naming conventions
    • Control flow expressions
    • Exceptions
    • Match expressions
    • Formatted text using printf
  • The “Understanding F# types” Series
    • Understanding F# types: Introduction
    • Overview of types in F#
    • Type abbreviations
    • Tuples
    • Records
    • Discriminated Unions
    • The Option type
    • Enum types
    • Built-in .NET types
    • Units of measure
    • Understanding type inference
  • Choosing between collection functions
  • The “Object-oriented programming in F#” Series
    • Object-oriented programming in F#: Introduction
    • Classes
    • Inheritance and abstract classes
    • Interfaces
    • Object expressions
  • The “Computation Expressions” Series
    • Computation expressions: Introduction
    • Understanding continuations
    • Introducing ‘bind’
    • Computation expressions and wrapper types
    • More on wrapper types
    • Implementing a builder: Zero and Yield
    • Implementing a builder: Combine
    • Implementing a builder: Delay and Run
    • Implementing a builder: Overloading
    • Implementing a builder: Adding laziness
    • Implementing a builder: The rest of the standard methods
  • Organizing modules in a project
  • The “Dependency cycles” Series
    • Cyclic dependencies are evil
    • Refactoring to remove cyclic dependencies
    • Cycles and modularity in the wild
  • The “Porting from C#” Series
    • Porting from C# to F#: Introduction
    • Getting started with direct porting
  • The “Designing with types” Series
    • Designing with types: Introduction
    • Single case union types
    • Making illegal states unrepresentable
    • Discovering new concepts
    • Making state explicit
    • Constrained strings
    • Non-string types
    • Designing with types: Conclusion
  • Algebraic type sizes and domain modelling
  • Thirteen ways of looking at a turtle
    • Thirteen ways of looking at a turtle (part 2)
    • Thirteen ways of looking at a turtle - addendum
  • How to design and code a complete program
  • A functional approach to error handling (Railway oriented programming)
    • Railway oriented programming: Carbonated edition
  • The “Understanding monoids” Series
    • Monoids without tears
    • Monoids in practice
    • Working with non-monoids
  • The “Understanding Parser Combinators” Series
    • Understanding Parser Combinators
    • Building a useful set of parser combinators
    • Improving the parser library
  • The “Handling State” Series
    • Dr Frankenfunctor and the Monadster
    • Completing the body of the Monadster
    • Refactoring the Monadster
  • The “Map and Bind and Apply, Oh my!” Series
    • Understanding map and apply
    • Understanding bind
    • Using the core functions in practice
    • Understanding traverse and sequence
    • Using map, apply, bind and sequence in practice
    • Reinventing the Reader monad
    • Map and Bind and Apply, a summary
  • The “Recursive types and folds” Series
    • Introduction to recursive types
    • Catamorphism examples
    • Introducing Folds
    • Understanding Folds
    • Generic recursive types
    • Trees in the real world
  • The “A functional approach to authorization” Series
    • A functional approach to authorization
    • Constraining capabilities based on identity and role
    • Using types as access tokens
  • Testing
    • An introduction to property-based testing
    • Choosing properties for property-based testing
  • Examples and Walkthroughs
    • Worked example: Designing for correctness
    • Worked example: A stack based calculator
    • Worked example: Parsing command line arguments
    • Worked example: Roman numerals
    • Commentary on ‘Roman Numerals Kata with Commentary’
    • Calculator Walkthrough: Part 1
      • Calculator Walkthrough: Part 2
      • Calculator Walkthrough: Part 3
      • Calculator Walkthrough: Part 4
    • Enterprise Tic-Tac-Toe
      • Enterprise Tic-Tac-Toe, part 2
    • Writing a JSON parser from scratch
  • Other
    • Ten reasons not to use a statically typed functional programming language
    • Why I won’t be writing a monad tutorial
    • Is your programming language unreasonable?
    • We don’t need no stinking UML diagrams
    • Introvert and extrovert programming languages
    • Swapping type-safety for high performance using compiler directives
暂无相关搜索结果！

    本文档使用 BookStack 构建

    展开/收起文章目录

    分享，让知识传承更久远

    文章二维码

    手机扫一扫，轻松掌上读

    文档下载

    • 普通下载
    • 下载码下载(免登录无限下载)
    你与大神的距离，只差一个APP
    APP下载
    请下载您需要的格式的文档，随时随地，享受汲取知识的乐趣！
    PDF文档 EPUB文档 MOBI文档
    温馨提示 每天每在网站阅读学习一分钟时长可下载一本电子书，每天连续签到可增加阅读时长
    下载码方式下载：免费、免登录、无限制。 免费获取下载码

    微信小程序阅读

    BookChat 微信小程序阅读
    您与他人的薪资差距，只差一个随时随地学习的小程序

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度