Pattern matching in functional programming languages is a way to break up expressions into individual cases.

We are going to go through how to pattern match in PureScript with simple patterns, guards, array patterns and record patterns.

greater :: Int -> Int -> Int
greater n m | n > m = n       -- ‘|‘ is called guard, the same as if else
            
 
| otherwise = m

isEmpty :: forall a. Array a -> Boolean  -- a in array should have same type
isEmpty [] = true
isEmpty _ = false

main = render =<< withConsole do 
  log $ show $ greater 3 2 -- 3
  log $ show $ greater 11 22 -- 22
  log $ show $ isEmpty [] -- true
  log $ show $ isEmpty [
 
1, 2] -- false

--

Full code:

module Main where

import Prelude
import Control.Monad.Eff.Console (log)
import TryPureScript

myTypes :: Int
myTypes = 1

-- add (a -> (b -> (a + b)))
add :: Int -> Int -> Int
add a b = a + b
addMe = \a -> \b -> a + b

-- inc (a -> (add 1 a))
inc :: Int 
 
-> Int
inc = add 1

-- Data constructors
data FooType = Foo | Bar String

runFoo :: FooType -> String
-- runFoo take a param Foo which should be string
runFoo Foo = "it is foo"
-- runFoo also can take Bar and String
-- <> is similar to str.concat isn JS
runFoo (Bar s) = "Yeah it‘s Bar and " <> s


greater :: Int -> Int -> Int
greater n m | n > m = n       -- ‘|‘ is called guard, the same as if else
            | otherwise = m

isEmpty :: forall a. Array a -> Boolean  -- a in array should have same type
isEmpty [] = true
isEmpty _ = false

main = render =<< withConsole do
  log $ show $ greater 3 2
  log $ show $ greater 11 22
  log $ show $ isEmpty []
  log $ show $ isEmpty [1, 2]

[PureScript] Break up Expressions into Cases in PureScript using Simple Pattern Matching