A Lens is a generalized getter and setter.

Lenses allow both the retrieval of values from fields in a record and the assignment of values to fields in a record. The power of a Lens comes from its ability to be composed with other lenses.

In the context of building applications with miso, the model is often a deeply nested product type. This makes it highly conducive to Lens operations (as defined below).

Type synonym re-export for lens / microlens compatability. Note: use this if you plan on migrating to lens or microlens eventually. Just use Lens otherwise (as examples show).

Smart constructor lens function. Used to easily construct a Lens

name :: Lens Person String
name = lens _name $ \p n -> p { _name = n }

Functor utility, a flipped infix fmap.

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

Set a field on a record

newtype Person = Person { _name :: String }

name :: Lens Person String
name = lens _name $ \person n -> person { _name = n }

setName :: Person -> String -> Person
setName person newName = person & name .~ newName

Set an options field on a record

newtype Person = Person { _name :: Maybe String }

name :: Lens Person (Maybe String)
name = lens _name $ \person n -> person { _name = n }

setName :: Person -> String -> Person
setName person newName = person & name ?~ newName

Synonym for (.~)

Modify a field on a record

\x -> record & field %~ f x

Synonym for (%~)

Read a field from a record using a Lens

newtype Person = Person { _name :: String }
  deriving (Show, Eq)

name :: Lens Person String
name = lens _name $ \person n -> person { _name = n }

getName :: Person -> String
getName = person ^. name

Increment a Numeric field on a record using a Lens

newtype Person = Person { _age :: Int }

age :: Lens Person Int
age = lens _age $ \person a -> person { _age = a }

birthday :: Person -> Person
birthday person = person & age +~ 1

Multiply a Numeric field on a record using a Lens

newtype Circle = Circle { _radius :: Int }

radius :: Lens Circle Int
radius = lens _radius $ \circle r -> circle { _radius = r }

expand :: Circle -> Circle
expand circle = circle & radius *~ 10

Divide a Fractional field on a record using a Lens

newtype Circle = Circle { _radius :: Int }

radius :: Lens Circle Int
radius = lens _radius $ \circle r -> circle { _radius = r }

expand :: Circle -> Circle
expand circle = circle & radius *~ 10

Increment a Numeric field on a record using a Lens

newtype Person = Person { _age :: Int }

age :: Lens Person Int
age = lens _age $ \person a -> person { _age = a }

timeTravel :: Person -> Person
timeTravel person = person & age -~ 1

Modify a record in MonadState monad at a field using a Lens

newtype Model = Model { _value :: Int }

data Action = AddOne | SubtractOne

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update AddOne = do
  value %= (+1)

Synonym for (%=)

Increments the value of a Numeric field of a record using a Lens inside a State Monad.

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = IncrementBy Int

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (IncrementBy x) = value += x

Multiplies the value of a Numeric field of a record using a Lens inside a State Monad.

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = MultiplyBy Int

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (MultiplyBy x) = value *= x

Divides the value of a Fractional field of a record using a Lens inside a State Monad.

newtype Model = Model { _value :: Double }
  deriving (Show, Eq)

data Action = DivideBy Double

value :: Lens Model Double
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (DivideBy x) = value //= x

Subtracts the value of a Numeric field of a record using a Lens inside of a State Monad.

newtype Model = Model { _value :: Double }
  deriving (Show, Eq)

data Action = SubtractBy Double

value :: Lens Model Double
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (SubtractBy x) = value -= x

Sets the value of a field in a record using MonadState and a Lens

import Miso.String (ms)

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = SetValue Int

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update' :: Action -> Effect Model Action ()
update' (SetValue v) = value .= v

Execute a monadic action in MonadState that returns a field. Sets the return value equal to the field in the record.

newtype List = List { _values :: [Int] }

values :: Lens List [Int]
values = lens _values $ \l vs -> l { _values = vs }

addElement :: List -> List
addElement list = list & values <>~ [2]

Modify the field of a record in MonadState using a Lens, then return the newly modified field from the updated record.

import Miso.String (ms)

newtype Model = Model { _value :: Int }
  deriving (Show)

data Action = AddOne

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update AddOne = do
  result <- value <%= (+1)
  io $ consoleLog (ms result)

Assign the field of a record in MonadState to a value using a Lens Return the value after assignment.

import Miso.String (ms)

newtype Model = Model { _value :: Int }

data Action = Assign Int

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (Assign x) = do
  result <- value <.= x
  io $ consoleLog (ms result) -- x

Assign the field of a record in a MonadState to a value (wrapped in a Just) using a Lens. Return the value after assignment.

import Miso.String (ms)

newtype Model = Model { _value :: Maybe Int }

data Action = SetValue Int

value :: Lens Model (Maybe Int)
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (SetValue x) = do
  result <- value <?= x
  io $ consoleLog (ms result) -- Just 1

Assign the field of a record in a MonadState to a value using a Lens. Returns the previous value, before assignment.

import Miso.String (ms)

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = Assign Int
  deriving (Show, Eq)

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (Assign x) = do
  value .= x
  previousValue <- value <<.= 1
  io $ consoleLog $ ms (show previousValue) -- prints value at x

Modifies the field of a record in MonadState using a Lens. Returns the previous value, before modification.

import Miso.String (ms)

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = Modify (Int -> Int)

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (Modify f) = do
  value .= 2
  result <- value <<%= f
  io $ consoleLog (ms (show result)) -- prints previous value of 2

Synonym for (.=)

Retrieves the value of a field in a record using a Lens inside MonadState

import Miso.String (ms)

newtype Model = Model { _value :: Int }
  deriving (Show, Eq)

data Action = SetValue Int

value :: Lens Model Int
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (SetValue x) = do
  value .= x
  result <- use value
  io $ consoleLog (ms (show result)) -- prints the value of 'x'

Sets the value of a field in a record using a Lens inside a MonadState The value is wrapped in a Just before being assigned.

newtype Model = Model { _value :: Maybe Int }
  deriving (Show, Eq)

data Action = AssignValue Int

value :: Lens Model (Maybe Int)
value = lens _value $ \p x -> p { _value = x }

update :: Action -> Effect Model Action ()
update (AssignValue x) = value ?= x

Monoidally append a field in a record using a Lens

newtype List = List { _values :: [Int] }

values :: Lens List [Int]
values = lens _values $ \l vs -> l { _values = vs }

addElement :: List -> List
addElement list = list & values <>~ [2]

addElement (List [])
-- List [2]