-
Notifications
You must be signed in to change notification settings - Fork 14
/
Options.purs
73 lines (59 loc) · 2.66 KB
/
Options.purs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
module Data.Options
( Options(..)
, options
, Option
, assoc, (:=)
, optional
, opt
, tag
, defaultToOptions
) where
import Prelude
import Data.Foreign (toForeign, Foreign)
import Data.Maybe (Maybe, maybe)
import Data.Monoid (mempty, class Monoid)
import Data.Newtype (class Newtype, unwrap)
import Data.Op (Op(..))
import Data.StrMap as StrMap
import Data.Tuple (Tuple(..))
-- | The `Options` type represents a set of options. The type argument is a
-- | phantom type, which is useful for ensuring that options for one particular
-- | API are not accidentally passed to some other API.
newtype Options opt = Options (Array (Tuple String Foreign))
derive instance newtypeOptions :: Newtype (Options opt) _
instance semigroupOptions :: Semigroup (Options opt) where
append (Options xs) (Options ys) = Options (xs <> ys)
instance monoidOptions :: Monoid (Options opt) where
mempty = Options []
-- | Convert an `Options` value into a JavaScript object, suitable for passing
-- | to JavaScript APIs.
options :: forall opt. Options opt -> Foreign
options (Options os) = toForeign (StrMap.fromFoldable os)
-- | An `Option` represents an opportunity to configure a specific attribute
-- | of a call to some API. This normally corresponds to one specific property
-- | of an "options" object in JavaScript APIs, but can in general correspond
-- | to zero or more actual properties.
type Option opt = Op (Options opt)
-- | Associates a value with a specific option.
assoc :: forall opt value. Option opt value -> value -> Options opt
assoc = unwrap
-- | An infix version of `assoc`.
infixr 6 assoc as :=
-- | A version of `assoc` which takes possibly absent values. `Nothing` values
-- | are ignored; passing `Nothing` for the second argument will result in an
-- | empty `Options`.
optional :: forall opt value. Option opt value -> Option opt (Maybe value)
optional option = Op $ maybe mempty (option := _)
-- | The default way of creating `Option` values. Constructs an `Option` with
-- | the given key, which passes the given value through unchanged.
opt :: forall opt value. String -> Option opt value
opt = Op <<< defaultToOptions
-- | Create a `tag`, by fixing an `Option` to a single value.
tag :: forall opt value. Option opt value -> value -> Option opt Unit
tag o value = Op \_ -> o := value
-- | The default method for turning a string property key into an
-- | `Option`. This function simply calls `toForeign` on the value. If
-- | you need some other behaviour, you can write your own function to replace
-- | this one, and construct an `Option` yourself.
defaultToOptions :: forall opt value. String -> value -> Options opt
defaultToOptions k v = Options [Tuple k (toForeign v)]