PureScript Documentation

A variable pattern matches any input and binds that input to the provided name for use in the result expression.

double x = x * 2

The case and of keywords allow deconstructing values based on their constructors.

• Multiple values: You can match on multiple values simultaneously by separating them with commas in the head and the cases.
• Guards: case expressions support guards using the | symbol.
• Anonymous arguments: Use a single underscore _ to match a value without binding it to a name.

f :: Maybe Boolean -> Either Boolean Boolean -> String
f a b = case a, b of
  Just true, Right true -> "Both true"
  Just true, Left _ -> "Just is true"
  Nothing, Right true -> "Right is true"
  _, _ -> "Both are false"

-- Using guards
f x = case x of
  Left x | x == 0 -> "Left zero"
         | x < 0 -> "Left negative"
         | otherwise -> "Left positive"
  Right _ -> "Right"

-- Anonymous argument
case _ of
  0 -> "None"
  1 -> "One"
  _ -> "Some"

A row is an unordered collection of named types. Rows have the kind Row k and cannot exist as values; they are used in type signatures to define records or other structures.

• Closed Rows: Defined by separating fields with commas and using :: between labels and types. Example: ( name :: String, age :: Number )
• Open Rows: Defined by separating specified fields from a row variable using a pipe |. Example: ( name :: String, age :: Number | r )

In PureScript, operators are regular binary functions (type a -> b -> c). You can create operator aliases using infixl, infixr, or infix followed by a precedence integer (0-9).

• infixl: Left-associative. Repeated applications are bracketed from the left.
• infixr: Right-associative. Repeated applications are bracketed from the right.
• infix: Non-associative. Repeated use of the same operator in a single expression is disallowed and results in a NonAssociativeError.

Types can also be aliased as operators using the type keyword.

data List a = Nil | Cons a (List a)

append :: forall a. List a -> List a -> List a
append xs Nil = xs
append Nil ys = ys
append (Cons x xs) ys = Cons x (append xs ys)

-- Define 'append' as a right-associative operator '<>' with precedence 5
infixr 5 append as <>

-- Usage
oneToSix = (Cons 1 (Cons 2 Nil)) <> (Cons 3 Nil)

The Warn type class (available in the Prim module) allows you to trigger custom compiler warnings by adding a constraint to a function. Warn is indexed by a Symbol. When the compiler solves a Warn constraint, it will print the provided message as a user-defined warning during compilation.

This is useful for providing guidance to users, such as suggesting alternative functions during a deprecation process.

import Data.Text (Text)
import Prim (Warn)

-- Example of a function that triggers a warning when used
notBad :: Warn (Text "`notBad` is deprecated. Prefer `better` instead.") => Int
notBad = 21

better :: Int
better = 42

Expressions can be polymorphic using the forall quantifier. This allows a function to operate on any type provided.

Example with type inference:

identity x = x
-- Inferred as: forall t0. t0 -> t0

Example with explicit type annotation:

identity :: forall a. a -> a
identity x = x

PureScript does not use [] syntactic sugar for lists.

• Use Data.List for linked lists.
• Use Array for native JavaScript arrays. Array values can be constructed using [x, y, z] literals, but the type must be annotated as Array a.

-- Array literal usage
myArray :: Array Int
myArray = [1, 2, 3]

Certain type classes are automatically solved by the PureScript compiler. You do not need to provide explicit instances or use derive instance statements for these classes. They are primarily used for type-level operations, error reporting, and row manipulations. These classes are located in the Prim modules.

foo :: forall t. (Warn "Custom warning message") => t -> t
foo x = x

The PureScript compiler only unwraps finite chains of newtypes.

If a newtype declaration contains an intervening constructor (like a function arrow ->), the compiler will attempt to unwrap the newtype to reach that constructor. If that unwrapping leads back to the same newtype, it results in the PossiblyInfiniteCoercibleInstance error.

However, if the newtype is strictly recursive without an intervening constructor, the compiler avoids the loop. For example:

newtype N a = N (N a)
type role N representational

When solving for Coercible (N a) (N b) in this specific case, the compiler does not unwrap the N constructor; instead, it decomposes the requirement to Coercible a b, which can then be discharged by the context.