Maker Pro

How to develop grammar checker app?- Part 1

June 01, 2018 by Daisy Rowley

Grammar checker working on 70%. During development this app I made many mistakes that I will correct.


0 GRA.2S.269.GN
0 CODEC5.1

As a writer, you understand the importance of making sure your work is free from any grammar mistakes, misspellings, and possible plagiarism issues. But the truth is that your word processor just cannot identify every type of grammar mistake, spelling error, or plagiarism problems. Simply put, word processors are unreliable and can cause you to publish or turn in inferior work that is filled with mistakes.

That is why writers from all professions trust Grammar app. Our grammar checker is the most powerful tool available for writers. And it is 100% for you to use!

What can Grammar app do for you?

Identify All Types of Grammar Mistakes

First and foremost, this is a grammar checker. Our powerful online application will scan your text for more than 150 different types of grammar mistakes. No stone is left unturned, and no other grammar check online is as thorough or accurate.

OK, let's start to write your code:

Here's a typical example of a 'counter' UI component and how it fits within the whole application:

import * as React from 'react'
import * as ReactDOM from 'react-dom'
import {
  // this is the special namespace with React components that accept
  // observable values in their props
} from '@grammarly/focal'
// our counter UI component
const Counter = (props: { count: Atom<number> }) =>
    {/* use observable state directly in JSX */}
    You have clicked this button {props.count} time(s).
      onClick={() =>
        // update the counter state on click
        props.count.modify(x => x + 1)
      Click again?
// the main 'app' UI component
const App = (props: { state: Atom<{ count: number }> }) =>
    Hello, world!
        // take the app state and lens into its part where the
        // counter's state lies.
        // note that this call is not simply a generic `map` over an
        // observable: it actually creates an atom which you can write to,
        // and in a type safe way. how is it type safe? see below.
        props.state.lens(x => x.count)
// create the app state atom
const state = Atom.create({ count: 0 })
// track any changes to the app's state and log them to console
state.subscribe(x => {
  console.log(`New app state: ${JSON.stringify(x)}`)
// render the app
  <App state={state} />,

You can play with this example online on CodeSandbox.

There's also a more elaborate version of this example, as well as some other examples, in the examples directory.


yarn add @grammarly/focal


npm install --save @grammarly/focal

It is important to satisfy the RxJS peer dependency (required for instanceof Observable tests to work correctly).

Also note, that for npm-based packages you will need npm 3.x. For Focal to work properly, you need to:

have the same version of RxJS installed in your package (listed as a peer dependency in Focal)

have RxJS installed in an npm 3.x way so that it is not duplicated in your app's node_modules and Focal's node_modules


The example above might be a bit too overwhelming. Let's go over the main concepts bit by bit.

Reactive variables

In Focal, state is stored in Atom<T>s. Atom<T> is a data cell that holds a single immutable value, which you can read and write to:


import { Atom } from '@grammarly/focal'
// create an Atom<number> with initial value of 0
const count = Atom.create(0)
// output the current value
// => 0
// set 5 as the new value
// => 5
// modify the value: set a new value which is based on current value
count.modify(x => x + 1)
// => 6

You can also track (get notified of) changes that happen to an Atom<T>'s value. In this sense, an Atom<T> can be thought of as a reactive variable:

import { Atom } from '@grammarly/focal'
const count = Atom.create(0)
// subscribe to changes of count's value, outputting a new value to the
// console each time
// NOTE how this will immediately output the current value
count.subscribe(x => {
// => 0
// => 0
// set a new value – it will get written to the console output
// => 5
count.modify(x => x + 1)
// => 6

Atom properties

Every atom is expected to satisfy these properties:

When .subscribed to, emit the current value immediately.

Don't emit a value if it is equal to the current value.

Single source of truth

Atom<T>s are used as a source of application state in Focal. There are more than one way in which you can create an Atom<T>, with Atom.create being the one that you use to create the application state root. Ideally, we want for the application state to come from a single source of truth. (We will talk about managing application state in this fashion below).

Although you can create as many Atom<T>s through Atom.create as you need, it generally should be avoided. The problem with having several (or many) sources of application state is that you may end up with different sorts of dependencies between these state sources, and there is no way to update several Atom<T>s at the same time. This can lead to inconsistency between the parts of your application state.

Here is how it works:

Copy and paste your text into the editor box on our website. Submit the text so the scan can begin. You do not have to upload anything!

A detailed report will be generated, identifying all grammatical errors in your text. The report is easy to understand, and it is generated fast.

Receive suggestions for correcting and improving all mistakes in your writing. That is right—we do not just tell you which mistakes you have made, we show you how to correct them too!

Scan Your Paper for Plagiarism Issues

The great thing about this program is that it is more than just an online grammar check tool; it is also a plagiarism scanning service.

When you submit your text, it will be compared against millions of published works. If any possible plagiarism issues are found, they will be highlighted and detailed in your free report. In addition to identifying possible plagiarism incidences, the report will include suggestions for correcting these issues so that your writing will be 100% original.

This is the best tool for guaranteeing the originality of your work. It can help all types of writers avoid the serious consequences of unintentional plagiarism.

Whether you are an author, student, professor, journalist, copywriter, business professional, or any other type of writer, you need to take the steps necessary to protect the originality of your work if you looking do my homework help. Our grammar check free online application will make sure plagiarism does not happen to you.

Identify All Types of Spelling Mistakes

Our spelling checker is the most powerful tool of its kind. While other similar programs only check for obvious misspellings, our application goes a step further. It identifies contextual spelling issues as well. These are spelling errors that are based on context, not actual misspellings. Other spelling checkers will overlook these errors, and your work can suffer as a result.

Only Grammar tool can give you 100% complete confidence that your writing is completely from any and all misspellings.

Related Content


You May Also Like