8eb5c5f · rowtype-yoga/purescript-vault

git.iko.soy/rowtype-yoga/purescript-vault

use JS Symbol

commit8eb5c5fc60835d845d3609a76a6db150ecdf026b authorJulien Chandra <mediapengunjungblog@gmail.com> dateMon 30 Oct 2017, 19:21 (9 years ago) parent73ffdb5

4 files changed+105−28

compare with master

unifiedsplit

bower.json+4−2 src/Data/Vault.purs+10−10 src/Data/Vault/Internal.js+49 src/Data/Vault/Internal.purs+42−16

bower.json+4−2

@@ -8,8 +8,10 @@

88 ],

99 "dependencies": {

1010 "purescript-prelude": "^3.1.0",

11− "purescript-maps": "^3.5.1",

12− "purescript-refs": "^3.0.0"

11+ "purescript-functions": "^3.0.0",

12+ "purescript-eff": "^3.1.0",

13+ "purescript-refs": "^3.0.0",

14+ "purescript-maybe": "^3.0.0"

1315 },

1416 "devDependencies": {

1517 "purescript-psci-support": "^3.0.0",

src/Data/Vault.purs+10−10

@@ -15,15 +15,15 @@ import Control.Monad.Eff (Eff)

1515import Control.Monad.Eff.Unsafe (unsafePerformEff)

1616import Control.Monad.Eff.Ref (REF, Ref, newRef, writeRef, modifyRef')

1717

18−import Data.Map as M

18+import Data.Function.Uncurried as Fn

1919import Data.Maybe (Maybe(..))

20−import Data.Vault.Internal (Unique, newUnique)

20+import Data.Vault.Internal as V

2121

2222-- | A persistent store for values of arbitrary types.

23−newtype Vault = Vault (M.Map Unique Item)

23+newtype Vault = Vault (V.UniqueMap Item)

2424

2525-- | Key for an item in vault

26−data Key a = Key Unique (Item' a)

26+data Key a = Key V.Unique (Item' a)

2727

2828type Item = Eff (ref :: REF) Unit

2929

@@ -31,33 +31,33 @@ type Item' a = Ref (Maybe a)

3131

3232-- | The empty vault

3333empty :: Vault

34−empty = Vault M.empty

34+empty = Vault V.empty

3535

3636-- | Create a new key for use with a vault.

3737newKey :: forall eff a. Eff (ref :: REF | eff) (Key a)

3838newKey = do

39− k <- newUnique

39+ k <- V.newUnique

4040 ref <- newRef Nothing

4141 pure $ Key k ref

4242

4343-- | Insert a value for a given key. Overwrites any previous value.

4444insert :: forall a. Key a -> a -> Vault -> Vault

45−insert (Key k ref) a (Vault m) = Vault (M.insert k (writeRef ref (Just a)) m)

45+insert (Key k ref) a (Vault m) = Vault (Fn.runFn3 V.insert k (writeRef ref (Just a)) m)

4646

4747-- | Delete a key from the vault.

4848delete :: forall a. Key a -> Vault -> Vault

49−delete (Key k _) (Vault m) = Vault (M.delete k m)

49+delete (Key k _) (Vault m) = Vault (Fn.runFn2 V.delete k m)

5050

5151-- | Lookup the value of a key in the vault.

5252lookup :: forall a. Key a -> Vault -> Maybe a

53−lookup (Key k ref) (Vault m) = case M.lookup k m of

53+lookup (Key k ref) (Vault m) = case Fn.runFn4 V.lookup Nothing Just k m of

5454 Nothing -> Nothing

5555 Just act -> unsafePerformEff do

5656 _ <- act

5757 modifyRef' ref rollItem

5858

5959union :: Vault -> Vault -> Vault

60−union (Vault m) (Vault n) = Vault (M.union m n)

60+union (Vault m) (Vault n) = Vault (Fn.runFn2 V.union m n)

6161

6262rollItem :: forall a. Maybe a -> { state :: Maybe a, value :: Maybe a }

6363rollItem a = { state: Nothing, value: a }

src/Data/Vault/Internal.jsnew file+49

@@ -0,0 +1,49 @@

1+"use strict";

3+exports.newUnique = function () {

4+ return Symbol();

5+};

7+exports.empty = Object.create(null);

9+function _copySM(m) {

10+ var keys = Object.getOwnPropertySymbols(m),

11+ sm = Object.create(null);

12+ for (var i = 0, len = keys.length; i < len; i++) {

13+ sm[keys[i]] = m[keys[i]];

14+ }

15+ return sm;

16+}

17+

18+exports.lookup = function (no, yes, k, m) {

19+ return k in m ? yes(m[k]) : no;

20+};

21+

22+exports.insert = function (k, v, m) {

23+ var n = _copySM(m);

24+ n[k] = v;

25+ return n;

26+}

27+

28+exports.delete = function (k, m) {

29+ var result = Object.create(null);

30+ var keys = Object.getOwnPropertySymbols(m);

31+ for (var i = 0, len = keys.length; i < len; i++) {

32+ if (keys[i] === k) continue;

33+ result[keys[i]] = m[keys[i]];

34+ }

35+ return result

36+}

37+

38+exports.union = function (m, n) {

39+ var result = Object.create(null);

40+ var k1 = Object.getOwnPropertySymbols(n);

41+ for (var i = 0, len = k1.length; i < len; i++) {

42+ result[k1[i]] = n[k1[i]];

43+ }

44+ var k2 = Object.getOwnPropertySymbols(m);

45+ for (var j = 0, length = k2.length; j < length; j++) {

46+ result[k2[j]] = n[k2[j]];

47+ }

48+ return result;

49+}

src/Data/Vault/Internal.purs+42−16

@@ -1,27 +1,53 @@

11module Data.Vault.Internal

22 ( Unique

33 , newUnique

4+ , UniqueMap

5+ , empty

6+ , lookup

7+ , insert

8+ , union

9+ , delete

410 ) where

511

6−import Prelude

7−

812import Control.Monad.Eff (Eff)

9−import Control.Monad.Eff.Unsafe (unsafePerformEff)

10−import Control.Monad.Eff.Ref (REF, Ref, newRef, modifyRef')

13+import Data.Function.Uncurried as Fn

14+import Data.Maybe (Maybe)

15+

16+foreign import data Unique :: Type

17+

18+foreign import newUnique :: forall eff. Eff eff Unique

19+

20+foreign import data UniqueMap :: Type -> Type

1121

12−-- | Store as Number, so it can handle 53-bit signed integer

13−newtype Unique = Unique Number

22+foreign import empty :: forall a. UniqueMap a

1423

15−derive newtype instance eqUnique :: Eq Unique

16−derive newtype instance ordUnique :: Ord Unique

24+foreign import delete

25+ :: forall a

26+ . Fn.Fn2

27+ Unique

28+ (UniqueMap a)

29+ (UniqueMap a)

1730

18−uniqueSource :: Ref Number

19−uniqueSource = unsafePerformEff $ newRef 0.00

31+foreign import lookup

32+ :: forall a

33+ . Fn.Fn4

34+ (forall x. Maybe x)

35+ (forall x. x -> Maybe x)

36+ Unique

37+ (UniqueMap a)

38+ (Maybe a)

2039

21−incrementSource :: Number -> { state :: Number, value :: Number }

22−incrementSource x = { state: x + one, value: x}

40+foreign import insert

41+ :: forall a

42+ . Fn.Fn3

43+ Unique

44+ a

45+ (UniqueMap a)

46+ (UniqueMap a)

2347

24−newUnique :: forall eff. Eff (ref :: REF | eff) Unique

25−newUnique = do

26− r <- modifyRef' uniqueSource incrementSource

27− pure $ Unique r

48+foreign import union

49+ :: forall a

50+ . Fn.Fn2

51+ (UniqueMap a)

52+ (UniqueMap a)

53+ (UniqueMap a)