Thanks to manofstick peer reviewing the blog post.
Full source code at github
For F# Advent 2021 I wrote a blog post exploring how F#6 [<InlineIfLambda>] can improve data pipeline performance.
I was thinking of other places where [<InlineIfLambda>] can help and decided to try to build a parser combinator library with [<InlineIfLambda>].
The current version of this document is here.
This document contains additional supporting material for the claims in this post (published 1 September 2019), in response to a cease and desist letter from John De Goes that I received on 6 July 2020.
Please see also this post for more information about De Goes deleting the FCoP repository on GitHub shortly before sending the cease and desist letter.
| module Payments where | |
| data Customer = Customer { name :: String, age :: Int } deriving (Eq, Ord, Show) | |
| -- I know partial record fields is an anti-pattern, but who's counting? | |
| data Payment | |
| = Cash { customer :: Customer, amount :: Double } | |
| | Credit { customer :: Customer, amount :: Double, cardNumber :: Int } | |
| | Check { customer :: Customer, amount :: Double, routingNumber :: Int, accountNumber :: Int } | |
| deriving (Eq, Ord, Show) |
| export const computeOffset = elt => { | |
| let rect = elt.getBoundingClientRect(); | |
| let width = rect.width; | |
| let height = rect.height; | |
| let left = 0; | |
| let top = 0; | |
| let offsetParent = elt; | |
| while (offsetParent) { | |
| left += offsetParent.offsetLeft; |
Functional reactive programming (FRP) is very popular nowadays. The JavaScript community provides us with excellent tools like RxJS, Bacon, and Kefir. But, as we know, they have nothing to do with React. So how we can use the power of FRP in our React application? Using the correct state management, we can make friends with FRP and React and make our application truly reactive. In my lightning talk, I will talk about Focal
Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.
A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.
val square : Int => Int = x => x * x| // Minimalistic Parser Combinator in F# | |
| // Neither Performance nor Error Reporting has been considered | |
| // For production code you are better off using http://www.quanttec.com/fparsec/ | |
| // Inspired by the classic: http://www.cs.nott.ac.uk/~pszgmh/monparsing.pdf | |
| [<Measure>] | |
| type ParserPos | |
| type ParserResult<'T> = 'T option*int<ParserPos> | |
| type Parser<'T> = string*int<ParserPos> -> ParserResult<'T> | |
| module Parser = |
Ten years ago, increasing the performance of a website usually meant tweaking the server side code to spit out responses faster. Web Performance engineering has come a long way since then. We have discovered patterns and practices that make the (perceived) performance of websites faster for users just by changing the way the front end code is structured, or tweaking the order of elements on a HTML page. Majority of the experiments and knowledge has been around delivering content to the user as fast as possible.
Today, web sites have grown to become complex applications that offer the same fidelity as applications installed on computers. Thus, consumers have also started to compare the user experience of native apps to the web applications. Providing a rich and fluid experience as users navigate web applications has started to play a major role in the success of the web.
Most modern browsers have excellent tools that help measure the runtime performa
These use separate document structures instead of HTML, some are more modular libraries than full editors
