Graphics.UI.Threepenny.Editors

Types and combinators to create widgets for editing algebraic datatypes.

This module builds around the idea that editors usually have the same shape as the data they are editing. We can immediately take advantage of this to automatically build editors from datatype definitions.

data Person = Person { first, last, email :: String, age :: Int }

deriveGeneric ''Person

instance Editable Person

This produces a generic editor with a fixed vertical layout. To customize the layout, we can use a explicit instance and monoidal layout builders:

instance Editable Person where
  editor = Person <$> fieldLayout Next  "First:" first editor
                  <*> fieldLayout Break "Last:"  last  editor
                  <*> fieldLayout Next  "Email:" email editor
                  <*> fieldLayout Next  "Age:"   age   editor

We can take this a step further by repurposing datatype definitions to represent not only data, but also the collections of editors that are composed to build the datatype editor. This is done via the Purpose type and the Field type family.

data Person purpose =
  Person { first, last, email :: Field purpose String
         , age                :: Field purpose Int}

deriveGeneric ''Person

instance Editable (Person Data) where
  type EditorWidget (Person Data) = Person Edit
  editor = editorGenericBi

instance Renderable (Person Edit) where
  render = renderGeneric

renderGeneric will produce a vertical layout. A direct implementation would use standard threepenny layout combinators since the fields of Person Edit are instances of Widget:

instance Renderable (Person Edit) where
  render Person{..} =
    grid [[string "First:", element first, string "Email:", element email]
         ,[string "Last:",  element last, string "Age:", element age]
         ]

Editors

newtype Editor outer widget inner

An editor for values of type inner inside a datatype outer realized by a widget.

All the three type arguments are functorial, but outer is contravariant, so Editor is a Biapplicative functor and a Profunctor (via dimapE).

Biapplicative allows to compose editors on both their widget and inner structure. When widget is monoidal, widget composition is implicit and Applicative suffices.

Profunctor allows to apply an inner editor to an outer datatype.

Once created, an Editor yields a tuple of an widget and a Tidings inner which can be integrated in a threepenny app.

Constructors

Editor

Fields

• create :: Behavior outer -> UI (GenericWidget widget inner)

Bundled Patterns

pattern Horizontally :: Editor a Layout b -> Editor a Horizontal b

Applicative modifier for horizontal composition of editor factories. This can be used in conjunction with ApplicativeDo as:

editorPerson = horizontally $ do
      firstName <- Horizontally $ field "First:" firstName editor
      lastName  <- Horizontally $ field "Last:"  lastName editor
      age       <- Horizontally $ field "Age:"   age editor
      return Person{..}

DEPRECATED: Use the Horizontal layout builder instead

pattern Vertically :: Editor a Layout b -> Editor a Vertical b

Applicative modifier for vertical composition of editor factories. This can be used in conjunction with ApplicativeDo as:

editorPerson = vertically $ do
      firstName <- Vertically $ field "First:" firstName editor
      lastName  <- Vertically $ field "Last:"  lastName editor
      age       <- Vertically $ field "Age:"   age editor
      return Person{..}

DEPRECATED: Use the Vertical layout builder instead

Instances

Bifunctor (Editor a)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

bimap :: (a0 -> b) -> (c -> d) -> Editor a a0 c -> Editor a b d

first :: (a0 -> b) -> Editor a a0 c -> Editor a b c

second :: (b -> c) -> Editor a a0 b -> Editor a a0 c

Biapplicative (Editor a)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

bipure :: a0 -> b -> Editor a a0 b

(<<*>>) :: Editor a (a0 -> b) (c -> d) -> Editor a a0 c -> Editor a b d

biliftA2 :: (a0 -> b -> c) -> (d -> e -> f) -> Editor a a0 d -> Editor a b e -> Editor a c f

(*>>) :: Editor a a0 b -> Editor a c d -> Editor a c d

(<<*) :: Editor a a0 b -> Editor a c d -> Editor a a0 b

Functor (Editor a el)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

fmap :: (a0 -> b) -> Editor a el a0 -> Editor a el b

(<$) :: a0 -> Editor a el b -> Editor a el a0

Monoid el => Applicative (Editor a el)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

pure :: a0 -> Editor a el a0

(<*>) :: Editor a el (a0 -> b) -> Editor a el a0 -> Editor a el b

liftA2 :: (a0 -> b -> c) -> Editor a el a0 -> Editor a el b -> Editor a el c

(*>) :: Editor a el a0 -> Editor a el b -> Editor a el b

(<*) :: Editor a el a0 -> Editor a el b -> Editor a el a0

class (HasEmpty a, Renderable (EditorWidget a), Renderable (ListEditorWidget a)) => Editable a where

The class of Editable datatypes.

There are several ways to create an instance, from easiest to most advanced:

• Automatically (via SOP), producing an editor with a vertical layout:

instance Editable MyDatatype

• Using the applicative layout combinators:

 instance Editable MyDatatype where
   editor = MyDatatype <$> field "Name:" name editor
                       -*- field "Age:"  age  editor

• Using a monoidal layout builder:

 instance Editable MyDatatype where
   editor = MyDatatype <$> fieldLayout Break "Name:" name editor
                       <*> fieldLayout Next  "Age:"  age  editor

• Using a dual purpose datatype, leaving the layout details for the Renderable instance.

instance Editable (MyDatatype Data) where
  type EditorWidget (MyDatatype Data) = MyDatatype Edit
  editor = editorGenericBi

Associated Types

type EditorWidget a

The widget type that realizes the editor. Defaults to Layout and only needs to be manually defined when using custom renderables.

type ListEditorWidget a

The widget type that realizes the editor for lists. Defaults to 'EditorCollection.

Methods

editor :: Editor a (EditorWidget a) a

listEditor :: Editor [a] (ListEditorWidget a) [a]

editor :: (Generic a, HasDatatypeInfo a, All (All Editable `And` All HasEmpty) (Code a), EditorWidget a ~ Layout) => Editor a (EditorWidget a) a

listEditor :: (HasEmpty a, ListEditorWidget a ~ EditorCollection Int (EditorWidget a)) => Editor [a] (ListEditorWidget a) [a]

Instances

Editable Bool

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget Bool :: *

type ListEditorWidget Bool :: *

Methods

editor :: Editor Bool (EditorWidget Bool) Bool

listEditor :: Editor [Bool] (ListEditorWidget Bool) [Bool]

Editable Char

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget Char :: *

type ListEditorWidget Char :: *

Methods

editor :: Editor Char (EditorWidget Char) Char

listEditor :: Editor [Char] (ListEditorWidget Char) [Char]

Editable Double

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget Double :: *

type ListEditorWidget Double :: *

Methods

editor :: Editor Double (EditorWidget Double) Double

listEditor :: Editor [Double] (ListEditorWidget Double) [Double]

Editable Int

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget Int :: *

type ListEditorWidget Int :: *

Methods

editor :: Editor Int (EditorWidget Int) Int

listEditor :: Editor [Int] (ListEditorWidget Int) [Int]

Editable ()

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget () :: *

type ListEditorWidget () :: *

Methods

editor :: Editor () (EditorWidget ()) ()

listEditor :: Editor [()] (ListEditorWidget ()) [()]

Editable Text

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget Text :: *

type ListEditorWidget Text :: *

Methods

editor :: Editor Text (EditorWidget Text) Text

listEditor :: Editor [Text] (ListEditorWidget Text) [Text]

Editable a => Editable [a]

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget [a] :: *

type ListEditorWidget [a] :: *

Methods

editor :: Editor [a] (EditorWidget [a]) [a]

listEditor :: Editor [[a]] (ListEditorWidget [a]) [[a]]

Editable (Maybe Double)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (Maybe Double) :: *

type ListEditorWidget (Maybe Double) :: *

Methods

editor :: Editor (Maybe Double) (EditorWidget (Maybe Double)) (Maybe Double)

listEditor :: Editor [Maybe Double] (ListEditorWidget (Maybe Double)) [Maybe Double]

Editable (Maybe Int)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (Maybe Int) :: *

type ListEditorWidget (Maybe Int) :: *

Methods

editor :: Editor (Maybe Int) (EditorWidget (Maybe Int)) (Maybe Int)

listEditor :: Editor [Maybe Int] (ListEditorWidget (Maybe Int)) [Maybe Int]

Editable a => Editable (Identity a)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (Identity a) :: *

type ListEditorWidget (Identity a) :: *

Methods

editor :: Editor (Identity a) (EditorWidget (Identity a)) (Identity a)

listEditor :: Editor [Identity a] (ListEditorWidget (Identity a)) [Identity a]

(Editable a, Editable b) => Editable (a -*- b)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (a -*- b) :: *

type ListEditorWidget (a -*- b) :: *

Methods

editor :: Editor (a -*- b) (EditorWidget (a -*- b)) (a -*- b)

listEditor :: Editor [a -*- b] (ListEditorWidget (a -*- b)) [a -*- b]

(Editable a, Editable b) => Editable (a |*| b)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (a |*| b) :: *

type ListEditorWidget (a |*| b) :: *

Methods

editor :: Editor (a |*| b) (EditorWidget (a |*| b)) (a |*| b)

listEditor :: Editor [a |*| b] (ListEditorWidget (a |*| b)) [a |*| b]

(All Editable xs, All HasEmpty xs) => Editable (NP I xs)

Defined in Graphics.UI.Threepenny.Editors

Associated Types

type EditorWidget (NP I xs) :: *

type ListEditorWidget (NP I xs) :: *

Methods

editor :: Editor (NP I xs) (EditorWidget (NP I xs)) (NP I xs)

listEditor :: Editor [NP I xs] (ListEditorWidget (NP I xs)) [NP I xs]

dimapE :: (a' -> a) -> (b -> b') -> Editor a el b -> Editor a' el b'

Editor composition

(|*|) :: Editor s Layout (b -> a) -> Editor s Layout b -> Editor s Layout a infixl 4

Left-right editor composition

(|*) :: Editor s Layout a -> UI Element -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(*|) :: UI Element -> Editor s Layout a -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(-*-) :: Editor s Layout (b -> a) -> Editor s Layout b -> Editor s Layout a infixl 4

Left-right editor composition

(-*) :: Editor s Layout a -> UI Element -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(*-) :: UI Element -> Editor s Layout a -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

field :: Renderable m => String -> (out -> inn) -> Editor inn m a -> Editor out Layout a

A helper that arranges a label and an editor horizontally.

fieldLayout :: (Renderable m, Renderable m') => (Layout -> m') -> String -> (out -> inn) -> Editor inn m a -> Editor out m' a

A helper that arranges a label and an editor horizontally, wrapped in the given monoidal layout builder.

withSomeWidget :: Renderable w => Editor a w b -> Editor a Layout b

Conceal the widget type of some Editor

Editor constructors

editorUnit :: Editor b Element b

editorIdentity :: Editor a el a -> Editor (Identity a) el (Identity a)

editorReadShow :: (Read a, Show a) => Editor (Maybe a) TextEntry (Maybe a)

editorEnumBounded :: (Bounded a, Enum a, Ord a, Show a) => Behavior (a -> UI Element) -> Editor (Maybe a) (ListBox a) (Maybe a)

editorSelection :: Ord a => Behavior [a] -> Behavior (a -> UI Element) -> Editor (Maybe a) (ListBox a) (Maybe a)

An editor that presents a dynamic choice of values.

editorSum :: (Ord tag, Show tag, Renderable el) => (Layout -> Layout -> Layout) -> [(tag, Editor a el a)] -> (a -> tag) -> Editor a Layout a

An editor for union types, built from editors for its constructors.

editorJust :: Editor (Maybe b) el (Maybe b) -> Editor b el b

Ignores Nothing values and only updates for Just values

editorString :: Editor String TextEntry String

editorText :: Editor Text TextEntry Text

editorCheckBox :: Editor Bool Element Bool

editorList :: (HasEmpty a, Renderable w) => Editor a w a -> Editor (Maybe Int, [a]) (EditorCollection Int w) (Maybe Int, [a])

A barebones editor for collections of editable items. Displays an index selector, add and delete buttons, and an editor for the selected item. Limitations: - Won't work with recursive data structures, due to the lack of FRP switch.

editorCollection :: forall k v w. (Ord k, Renderable w) => (Behavior (Maybe k, Map k v) -> EditorCollectionConfig k v) -> Editor v w v -> Editor (Maybe k, Map k v) (EditorCollection k w) (Maybe k, Map k v)

A barebones editor for collections of editable items. Displays an index selector, add and delete buttons, and an editor for the selected item. Limitations: - Won't work with recursive data structures, due to the lack of FRP switch.

data EditorCollection k w

Instances

Renderable w => Renderable (EditorCollection k w)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

render :: EditorCollection k w -> UI Element

getLayout :: EditorCollection k w -> Layout

someEditor :: Editable a => Editor a Layout a

A version of editor with a concealed widget type.

withSomeWidget :: Renderable w => Editor a w b -> Editor a Layout b

Conceal the widget type of some Editor

Dual purpose datatypes

type family Field (purpose :: Purpose) a where ...

Type level fields. Used to define dual purpose datatype constructors, which can be instantiated to either store data or widgets. Example:

data PersonF (purpose :: Purpose) = Person
  { education           :: Field purpose Education
  , firstName, lastName :: Field purpose Text
  , age                 :: Field purpose (Maybe Int)
  }

type Person = PersonF Data
type PersonEditor = PersonF Edit

Equations

Field Data a = a

Field Edit a = EditorWidget a

type family ListField (purpose :: Purpose) a where ...

List version of Field. Example:

data PersonF (purpose :: Purpose) = Person
  { education           :: Field purpose Education
  , firstName, lastName :: Field purpose Text
  , age                 :: Field purpose (Maybe Int)
  , addresses           :: ListField purpose String
  }

type Person = PersonF Data
type PersonEditor = PersonF Edit

Equations

ListField Data a = [a]

ListField Edit a = ListEditorWidget a

data Purpose

Purpose is a kind for type level Fields

Constructors

Data

Edit

Generic editors

editorGeneric :: forall a. (Generic a, HasDatatypeInfo a, All (All Editable `And` All HasEmpty) (Code a)) => Editor a Layout a

A generic editor derivation for SOP types.

The datatype arguments are layered in vertical fashion and labelled with field names if available.

editorGenericBi :: forall xs typ. (Generic (typ Data), Generic (typ Edit), All Editable xs, Code (typ Data) ~ '[xs], Code (typ Edit) ~ '[EditorWidgetsFor xs]) => Editor (typ Data) (typ Edit) (typ Data)

A generic editor derivation for dual purpose datatypes with a single constructor.

e.g. for the datatype

 data Person purpose = Person { firstName, lastName :: Field purpose String }

 instance Editable (Person Data) where
     type EditorWidget (Person Data) = Person Edit
     editor = editorGenericBi

will be equivalent to

instance Editable (Person Data) where
 type EditorWidget (Person Data) = Person Edit
 editor = bipure DataItem DataItem
             <<*>> edit firstName editor
             <<*>> edit lastName editor

Widgets

data GenericWidget control a

Constructors

GenericWidget

Fields

• widgetTidings :: Tidings a

  The dynamic contents of the widget.

• widgetControl :: control

  The actual widget.

Instances

Bifunctor GenericWidget

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

bimap :: (a -> b) -> (c -> d) -> GenericWidget a c -> GenericWidget b d

first :: (a -> b) -> GenericWidget a c -> GenericWidget b c

second :: (b -> c) -> GenericWidget a b -> GenericWidget a c

Functor (GenericWidget control)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

fmap :: (a -> b) -> GenericWidget control a -> GenericWidget control b

(<$) :: a -> GenericWidget control b -> GenericWidget control a

Widget el => Widget (GenericWidget el a)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

getElement :: GenericWidget el a -> Element

Renderable el => Renderable (GenericWidget el a)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

render :: GenericWidget el a -> UI Element

getLayout :: GenericWidget el a -> Layout

edited :: GenericWidget el a -> Event a

contents :: GenericWidget el a -> Behavior a

Layouts

data Layout

A rathe limited, grid layout builder, probably not fit for general purpose use yet.

Instances

Renderable Layout

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Layout -> UI Element

getLayout :: Layout -> Layout

Monoidal layouts

newtype Vertical

A monoidal layout builder that places everything in a single column

Constructors

Vertical

Fields

• getVertical :: Layout

Instances

Semigroup Vertical

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

(<>) :: Vertical -> Vertical -> Vertical

sconcat :: NonEmpty Vertical -> Vertical

stimes :: Integral b => b -> Vertical -> Vertical

Monoid Vertical

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

mempty :: Vertical

mappend :: Vertical -> Vertical -> Vertical

mconcat :: [Vertical] -> Vertical

Renderable Vertical

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Vertical -> UI Element

getLayout :: Vertical -> Layout

newtype Horizontal

A monoidal layout builder that places everything in a single row

Constructors

Horizontal

Fields

• getHorizontal :: Layout

Instances

Semigroup Horizontal

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

(<>) :: Horizontal -> Horizontal -> Horizontal

sconcat :: NonEmpty Horizontal -> Horizontal

stimes :: Integral b => b -> Horizontal -> Horizontal

Monoid Horizontal

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

mempty :: Horizontal

mappend :: Horizontal -> Horizontal -> Horizontal

mconcat :: [Horizontal] -> Horizontal

Renderable Horizontal

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Horizontal -> UI Element

getLayout :: Horizontal -> Layout

data Columns

A monoidal layout builder that lays elements in columns

Constructors

Next Layout

Continue in the same column

Break Layout

Continue in the next column

Instances

Show Columns

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

showsPrec :: Int -> Columns -> ShowS

show :: Columns -> String

showList :: [Columns] -> ShowS

Semigroup Columns

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

(<>) :: Columns -> Columns -> Columns

sconcat :: NonEmpty Columns -> Columns

stimes :: Integral b => b -> Columns -> Columns

Monoid Columns

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

mempty :: Columns

mappend :: Columns -> Columns -> Columns

mconcat :: [Columns] -> Columns

Renderable Columns

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Columns -> UI Element

getLayout :: Columns -> Layout

Custom layout definition

class Renderable w where

Closely related to Widget, this class represents types that can be rendered to an Element, either directly or via Layout.

Minimal complete definition

render | getLayout

Methods

render :: w -> UI Element

getLayout :: w -> Layout

Instances

Renderable String

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: String -> UI Element

getLayout :: String -> Layout

Renderable TextEntry

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: TextEntry -> UI Element

getLayout :: TextEntry -> Layout

Renderable Element

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Element -> UI Element

getLayout :: Element -> Layout

Renderable Columns

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Columns -> UI Element

getLayout :: Columns -> Layout

Renderable Horizontal

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Horizontal -> UI Element

getLayout :: Horizontal -> Layout

Renderable Vertical

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Vertical -> UI Element

getLayout :: Vertical -> Layout

Renderable Layout

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: Layout -> UI Element

getLayout :: Layout -> Layout

Renderable (ListBox a)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: ListBox a -> UI Element

getLayout :: ListBox a -> Layout

Renderable a => Renderable (UI a)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: UI a -> UI Element

getLayout :: UI a -> Layout

(Renderable a, Renderable b) => Renderable (a -*- b)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: (a -*- b) -> UI Element

getLayout :: (a -*- b) -> Layout

(Renderable a, Renderable b) => Renderable (a |*| b)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

render :: (a |*| b) -> UI Element

getLayout :: (a |*| b) -> Layout

Renderable w => Renderable (EditorCollection k w)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

render :: EditorCollection k w -> UI Element

getLayout :: EditorCollection k w -> Layout

Renderable el => Renderable (GenericWidget el a)

Defined in Graphics.UI.Threepenny.Editors.Types

Methods

render :: GenericWidget el a -> UI Element

getLayout :: GenericWidget el a -> Layout

renderGeneric :: forall a xs. (Generic a, HasDatatypeInfo a, All Renderable xs, Code a ~ '[xs]) => a -> UI Element

A generic render derivation for data types with a single constructor which renders the (labelled) fields in a vertical layout. For custom layouts use getLayoutGeneric.

e.g. given the declarations

data PersonEditor = PersonEditor { firstName, lastName :: EditorWidget String }
deriveGeneric ''PersonEditor

using renderGeneric to instantiate Renderable

instance Renderable PersonEditor where
  getLayout = renderGeneric

will be equivalent to writing the below by hand

instance Renderable PersonEditor where
  getLayout PersonEditor{..} =
      grid [ [string "First name:", element firstName]
           , [string "Last name:",  element lastName ]
           ]

getLayoutGeneric :: forall a xs. (Generic a, HasDatatypeInfo a, All Renderable xs, Code a ~ '[xs]) => a -> [[Layout]]

A helper to implement getLayout for data types with a single constructor. Given a value, getLayoutGeneric returns a grid of Layouts with one row per field. Rows can carry one element, for unnamed fields; two elements, for named fields; or three elements, for operators.

Representing empty values

class HasEmpty a where

This class defines how to represent empty values in a UI. A generic derivation is available for every SOP type.

Methods

emptyValue :: a

emptyValue :: (Generic a, HasEmptyCode (Code a), All HasEmpty (Head (Code a))) => a

Instances

HasEmpty Bool

Defined in Data.HasEmpty

Methods

emptyValue :: Bool

HasEmpty Char

Defined in Data.HasEmpty

Methods

emptyValue :: Char

HasEmpty Double

Defined in Data.HasEmpty

Methods

emptyValue :: Double

HasEmpty Int

Defined in Data.HasEmpty

Methods

emptyValue :: Int

HasEmpty ()

Defined in Data.HasEmpty

Methods

emptyValue :: ()

HasEmpty Text

Defined in Data.HasEmpty

Methods

emptyValue :: Text

HasEmpty [a]

Defined in Data.HasEmpty

Methods

emptyValue :: [a]

HasEmpty (Maybe a)

Defined in Data.HasEmpty

Methods

emptyValue :: Maybe a

HasEmpty a => HasEmpty (Identity a)

Defined in Data.HasEmpty

Methods

emptyValue :: Identity a

HasEmpty (Seq k)

Defined in Data.HasEmpty

Methods

emptyValue :: Seq k

Ord k => HasEmpty (Set k)

Defined in Data.HasEmpty

Methods

emptyValue :: Set k

HasEmpty a => HasEmpty (I a)

Defined in Graphics.UI.Threepenny.Editors

Methods

emptyValue :: I a

(HasEmpty a, HasEmpty b) => HasEmpty (a, b)

Defined in Data.HasEmpty

Methods

emptyValue :: (a, b)

Ord k => HasEmpty (Map k v)

Defined in Data.HasEmpty

Methods

emptyValue :: Map k v

(HasEmpty a, HasEmpty b) => HasEmpty (a -*- b)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

emptyValue :: a -*- b

(HasEmpty a, HasEmpty b) => HasEmpty (a |*| b)

Defined in Graphics.UI.Threepenny.Editors.Layout

Methods

emptyValue :: a |*| b

All HasEmpty xs => HasEmpty (NP I xs)

Defined in Graphics.UI.Threepenny.Editors

Methods

emptyValue :: NP I xs

Orphan instances

HasEmpty a => HasEmpty (I a)

Methods

emptyValue :: I a

All HasEmpty xs => HasEmpty (NP I xs)

Methods

emptyValue :: NP I xs