Learn Ramda and Svelte

JavaScript community has been shaken recently by a release of Svelte 3 and for a good reason - it's a completely different approach than React or Vue. To quote the docs:

"[Svelte](https://svelte.dev/) is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app."

**The best part?** If you have 26 spare minutes you can learn the basics of Svelte 3 and start building your own apps with it!

Enjoy!



The magical disappearing UI framework

 - The web's JavaScript bloat crisis, solved. Svelte turns your templates into tiny, framework-less vanilla JavaScript.
 - Simple and familiar. Build apps out of composable, easy-to-write blocks using languages you already know.
 - Super fast, rock solid. Compile-time static analysis ensures the browser does no more work than it needs to.

svelte

Up and running with Svelte 3

Learn how you can use ramda.js to bring functional programming concepts into your JavaScript code. Ramda offers composability and immutability right out of the box, so you can leave your imperative code behind and build cleaner, more maintainable code.

A library designed specifically for a functional programming style, one that makes it easy to create functional pipelines, one that never mutates user data.

ramda

Functional Programming in JavaScript with Ramda.js

Creating forms is one of the simplest and most complicated things at the same time. A basic form consists of many different things happening, we have to retain the value, we have to keep watch of validation and we have to show error messages when something is invalid, this is on both the fields and on the entire form itself if we send a request off to the backend service.

So we're going to create a form using just the normal svelte features. Then we'll look into creating a form using the svelte forms lib. 

Create forms in Svelte with Svelte Forms Lib

In this lesson we'll look at how you can use Ramda's `unfold` function to generate a list of values based on an initial seed.

Create an Array From a Seed Value with Ramda's unfold

Functional composition is a great way to write declarative code that reads well. But sometimes, you need to get insight into what's happening at different steps in your composition. This is where `tap` comes in. With tap, we can run code that generates side-effects, like logging to the console, and our data will continue to be passed along, untouched.

Debug Function Compositions with Ramda's Tap Function

Most of the functions offered by the ramda library are curried by default. Functions you've created or that you've pulled in from another library may not be curried. Ramda's `curry` and `curryN` functions allow you to take a non-curried function and use it as a curried functions. In the case where you have a manually curried function and you want to just call it like a normal function, you can use `uncurryN` to get back a function that accepts all of the arguments at once.

Curry and Uncurry Functions with Ramda

You can really unlock the power of ramda (and functional programming in general) when you combine functions. Counting words in a string may seem like a relatively difficult task, but ramda makes it easy by providing a `countBy` function.  This lesson walks through using the `countBy` to count words in a string.

Count Words in a String with Ramda's countBy and invert

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

In this lesson, we'll refactor a React component to use Ramda lenses to update our component state. We'll create a lens to focus on the property we want to target and use `over` to apply the existing state value to a utility function and we'll get back a new state that will be reflected in our rendered UI.

Update Component State in React With Ramda Lenses

Using the map method of an array is a great way to create new data from an existing array in an immutable way and without writing any loops. The problem is that you need to call it on an existing array instance. In the lesson we'll see how to build our own reusable `map` utility function using manual currying and then we'll replace it with Ramda's `map`.

Create a Reusable Mapping Function with Ramda's Map

In this lesson, we'll use `Promise.all` to get an array that contains the resolved values from multiple promises. Then we'll see how we can use Ramda to convert that array of values into a single object using `zip` with `fromPairs`. Then we'll refactor to use `zipObj`.

Convert a Promise.all Result to an Object with Ramda's zip and zipObj

We don't always control the data we need in our applications, and that means we often find ourselves massaging and transforming our data. In this lesson, we'll learn how to transform objects in a declarative way using ramda's evolve function.

Declaratively Map Data Transformations to Object Properties Using Ramda evolve

In this lesson we'll see how Ramda's `path` and `pathOr` functions can be used to safely access a deeply nested property from an object while avoiding the dreaded checks for `undefined` at each new property in the desired path. 

Get Deeply Nested Properties Safely with Ramda's path and pathOr Functions

Sometimes you need to filter an array of objects or perform other conditional logic based on a combination of factors. Ramda's `where` function gives you a concise way to declaratively map individual predicates to object properties, that when combined, cover the various facets of your conditions. In this lesson, we'll look at how this powerful function can be used for scenarios requiring a complex predicate function.

Declaratively Map Predicates to Object Properties Using Ramda where

In this lesson we'll take an array of objects and map it to a new array where each object is a subset of the original. We'll look at multiple ways to accomplish this, refactoring our code into a simple and easy to read function using Ramda's `map`, `pick` and `project` functions.

Select a Subset of Properties from a Collection of Objects in Ramda

We'll learn how to get a subset of an array by specifying items to include with filter, or items to exclude using reject. We'll also look at how to get the results from both filter and reject, neatly separated with partition.

Add and Remove Items in Arrays using Filter, Reject and Partition in Ramda

In this lesson we'll learn the basics of using lenses in Ramda and see how they enable you to focus changes on specific properties of an object while keeping your data immutable. 

Change Object Properties with Ramda Lenses

Sorting an array of objects by multiple fields can be tricky. Even worse, the code can be tough to follow and making changes in the future is complicated by conditional logic in the sorting function. In this lesson we'll see how to simplify this using Ramda's `sortWith` along with `ascending` and `descending`. We'll sort an array of objects by multiple fields and the code will be readable and dead simple to change.

Sort an Array of Objects by Multiple Fields with Ramda's sortWith

Sometimes you just need a subset of an object. In this lesson, we'll cover how you can accomplish this using Ramda's pick and omit functions, as well as the pickAll and pickBy variants of pick. 

Pick and Omit Properties from Objects Using Ramda

Handling your logic with composable functions makes your code declarative, leading to code that's easy to read and easy to test. Breaking that up to wrap some risky function in a `try/catch` block introduces imperative code and makes it harder to maintain that declarative approach. With Ramda's `tryCatch` function, you can handle errors right in the middle of a composition and leave your code clean and functional. We'll also see how you can use `propOr` to avoid common "cannot find X of undefined" errors.

Handle Errors in Ramda Pipelines with tryCatch

In this lesson we'll take some existing code and refactor it using some functions from the Ramda library, most notably, `compose` and `converge`. When we're done, we'll have taken a function with a couple of local variables and parameter references and converted it into more streamlined "point-free" or "tacit" functions.

Refactor to Point Free Functions with Ramda using compose and converge

Naming things is hard and arguments in generic utility functions are no exception. Making functions "tacit" or "point free" removes the need for the extra parameter names and can make your code cleaner and more succinct. In this lesson, we'll create a normal, "pointed" function and then use ramda's `useWith` function to refactor our way to point-free bliss.