Merge pull request #38 from purescript/compiler/0.12

Update for PureScript 0.12

Author: garyb

.gitignore

@@ -5,3 +5,4 @@ package-lock.json
 /bower_components/
 /node_modules/
 /output/
+package-lock.json

LICENSE

@@ -1,20 +1,26 @@
-The MIT License (MIT)
+Copyright 2018 PureScript
 
-Copyright (c) 2016 PureScript
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

bower.json

@@ -2,7 +2,7 @@
   "name": "purescript-typelevel-prelude",
   "homepage": "https://github.com/purescript/purescript-typelevel-prelude",
   "description": "Types and kinds for basic type-level programming",
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
     "url": "git://github.com/purescript/purescript-typelevel-prelude.git"
@@ -16,8 +16,8 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-proxy": "^2.0.0",
-    "purescript-symbols": "^3.0.0",
-    "purescript-type-equality": "^2.0.0"
+    "purescript-proxy": "^3.0.0",
+    "purescript-prelude": "^4.0.0",
+    "purescript-type-equality": "^3.0.0"
   }
 }

package.json

@@ -5,8 +5,8 @@
     "build": "pulp build -- --censor-lib --strict"
   },
   "devDependencies": {
-    "pulp": "^10.0.4",
-    "purescript-psa": "^0.5.0-rc.1",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.2.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Type/Data/Ordering.purs

@@ -1,28 +1,21 @@
 module Type.Data.Ordering
-  ( kind Ordering
-  , LT
-  , EQ
-  , GT
+  ( module Prim.Ordering
   , OProxy(..)
   , class IsOrdering
   , reflectOrdering
   , reifyOrdering
-  , class AppendOrdering
-  , appendOrdering
-  , class InvertOrdering
-  , invertOrdering
+  , class Append
+  , append
+  , class Invert
+  , invert
   , class Equals
   , equals
   ) where
 
+import Prim.Ordering (kind Ordering, LT, EQ, GT)
 import Data.Ordering (Ordering(..))
 import Type.Data.Boolean (kind Boolean, True, False, BProxy(..))
 
-foreign import kind Ordering
-foreign import data LT :: Ordering
-foreign import data EQ :: Ordering
-foreign import data GT :: Ordering
-
 -- | Value proxy for `Ordering` types
 data OProxy (ordering :: Ordering) = OProxy
 
@@ -42,27 +35,27 @@ reifyOrdering GT f = f (OProxy :: OProxy GT)
 
 -- | Append two `Ordering` types together
 -- | Reflective of the semigroup for value level `Ordering`
-class AppendOrdering (lhs :: Ordering)
-                     (rhs :: Ordering)
-                     (output :: Ordering) |
-                     lhs -> rhs output
-instance appendOrderingLT :: AppendOrdering LT rhs LT
-instance appendOrderingEQ :: AppendOrdering EQ rhs rhs
-instance appendOrderingGT :: AppendOrdering GT rhs GT
+class Append (lhs :: Ordering)
+             (rhs :: Ordering)
+             (output :: Ordering) |
+             lhs -> rhs output
+instance appendOrderingLT :: Append LT rhs LT
+instance appendOrderingEQ :: Append EQ rhs rhs
+instance appendOrderingGT :: Append GT rhs GT
 
-appendOrdering :: forall l r o. AppendOrdering l r o => OProxy l -> OProxy r -> OProxy o
-appendOrdering _ _ = OProxy
+append :: forall l r o. Append l r o => OProxy l -> OProxy r -> OProxy o
+append _ _ = OProxy
 
 -- | Invert an `Ordering`
-class InvertOrdering (ordering :: Ordering)
-                     (result :: Ordering) |
-                     ordering -> result
-instance invertOrderingLT :: InvertOrdering LT GT
-instance invertOrderingEQ :: InvertOrdering EQ EQ
-instance invertOrderingGT :: InvertOrdering GT LT
+class Invert (ordering :: Ordering)
+             (result :: Ordering) |
+             ordering -> result
+instance invertOrderingLT :: Invert LT GT
+instance invertOrderingEQ :: Invert EQ EQ
+instance invertOrderingGT :: Invert GT LT
 
-invertOrdering :: forall i o. InvertOrdering i o => OProxy i -> OProxy o
-invertOrdering _ = OProxy
+invert :: forall i o. Invert i o => OProxy i -> OProxy o
+invert _ = OProxy
 
 class Equals (lhs :: Ordering)
              (rhs :: Ordering)

src/Type/Data/Symbol.purs

@@ -1,44 +1,35 @@
 module Type.Data.Symbol
-  ( module Data.Symbol
-  , class CompareSymbol
-  , compareSymbol
-  , class AppendSymbol
-  , appendSymbol
+  ( module Prim.Symbol
+  , module Data.Symbol
+  , append
+  , compare
+  , uncons
   , class Equals
   , equals
   ) where
 
+import Prim.Symbol (class Append, class Compare, class Cons)
 import Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol)
 import Type.Data.Ordering (OProxy(..), kind Ordering, EQ)
 import Type.Data.Ordering (class Equals) as Ordering
 import Type.Data.Boolean (kind Boolean, BProxy(..))
 
--- | Compare two `Symbol` types
-class CompareSymbol (lhs :: Symbol)
-                    (rhs :: Symbol)
-                    (out :: Ordering) |
-                    lhs rhs -> out
+compare :: forall l r o. Compare l r o => SProxy l -> SProxy r -> OProxy o
+compare _ _ = OProxy
 
-compareSymbol :: forall l r o. CompareSymbol l r o => SProxy l -> SProxy r -> OProxy o
-compareSymbol _ _ = OProxy
+append :: forall l r o. Append l r o => SProxy l -> SProxy r -> SProxy o
+append _ _ = SProxy
 
-
--- | Append two `Symbol` types together
-class AppendSymbol (lhs :: Symbol)
-                   (rhs :: Symbol)
-                   (out :: Symbol) |
-                   lhs rhs -> out
-
-appendSymbol :: forall l r o. AppendSymbol l r o => SProxy l -> SProxy r -> SProxy o
-appendSymbol _ _ = SProxy
+uncons :: forall h t s. Cons h t s => SProxy s -> {head :: SProxy h, tail :: SProxy t}
+uncons _ = {head : SProxy, tail : SProxy}
 
 class Equals (lhs :: Symbol)
              (rhs :: Symbol)
              (out :: Boolean) |
              lhs rhs -> out
 
 instance equalsSymbol
-  :: (CompareSymbol lhs rhs ord,
+  :: (Compare lhs rhs ord,
       Ordering.Equals EQ ord out)
   => Equals lhs rhs out
 

src/Type/Prelude.purs

@@ -10,7 +10,7 @@ module Type.Prelude
 import Type.Data.Boolean (kind Boolean, True, False, BProxy(..), class IsBoolean, reflectBoolean, reifyBoolean)
 import Type.Data.Ordering (kind Ordering, LT, EQ, GT, OProxy(..), class IsOrdering, reflectOrdering, reifyOrdering)
 import Type.Proxy (Proxy(..))
-import Type.Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol, class CompareSymbol, compareSymbol, class AppendSymbol, appendSymbol)
+import Type.Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol, class Compare, compare, class Append, append)
 import Type.Equality (class TypeEquals, from, to)
-import Type.Row (class RowLacks, class RowToList, class ListToRow, RProxy(..), RLProxy(..))
+import Type.Row (class Union, class Lacks, class RowToList, class ListToRow, RProxy(..), RLProxy(..))
 

src/Type/Row.purs

@@ -1,12 +1,8 @@
 module Type.Row
   ( RProxy(..)
-  , class RowLacks
-  , class RowLacking
-  , kind RowList
-  , Nil
-  , Cons
+  , module Prim.Row
+  , module Prim.RowList
   , RLProxy(..)
-  , class RowToList
   , class ListToRow
   , class RowListRemove
   , class RowListSet
@@ -16,57 +12,16 @@ module Type.Row
   , type (+)
   ) where
 
+import Prim.Row (class Lacks, class Nub, class Cons, class Union)
+import Prim.RowList (kind RowList, Cons, Nil, class RowToList)
 import Type.Equality (class TypeEquals)
 import Type.Data.Symbol as Symbol
 import Type.Data.Boolean as Boolean
 
 data RProxy (row :: # Type) = RProxy
 
--- Must not be exported
-foreign import data Entry :: Type
-
--- | If you get "No type class instance was found" for this class, then your
--- | `row` shouldn't contain the label `key`.
-class RowLacking (entry :: Type)
-                 (key :: Symbol)
-                 (typ :: Type)
-                 (row :: # Type) |
-                 entry typ -> key row
-
-instance rowLacking :: RowLacking entry key entry row
-
--- | Encodes the constraint that a given row does not contain a specific key.
-class RowLacks (key :: Symbol)
-               (row :: # Type)
-
--- Append `Entry` at label `key` to the right of `row` then lookup `key` on the
--- left - if we check via instance solving that the `typ` we get back is
--- `Entry`, then `row` lacks `key`.  In the case that `row` doesn't lack
--- `key`, we get a "No type class instance found" error for:
--- `RowLacking Entry key typ row`.
-instance rowLacks
-  :: ( RowCons key Entry () keyEntry
-     , Union row keyEntry rowKeyEntry
-     , RowCons key typ ignored rowKeyEntry
-     , RowLacking Entry key typ row )
-  => RowLacks key row
-
-
--- | A type-level list representation of a row
-foreign import kind RowList
-foreign import data Nil :: RowList
-foreign import data Cons :: Symbol -> Type -> RowList -> RowList
-
 data RLProxy (rowList :: RowList) = RLProxy
 
--- | Extract the collection of entries in a closed row of types.
--- | The list of entries is sorted by label and preserves duplicates.
--- | The inverse of this operation is `ListToRow`.
--- | Solved by the compiler.
-class RowToList (row :: # Type)
-                (list :: RowList) |
-                row -> list
-
 -- | Convert a RowList to a row of types.
 -- | The inverse of this operation is `RowToList`.
 class ListToRow (list :: RowList)
@@ -76,9 +31,9 @@ class ListToRow (list :: RowList)
 instance listToRowNil
   :: ListToRow Nil ()
 
-instance listToRowCons
+instance listToCons
   :: ( ListToRow tail tailRow
-     , RowCons label ty tailRow row )
+     , Cons label ty tailRow row )
   => ListToRow (Cons label ty tail) row
 
 -- | Remove all occurences of a given label from a RowList

src/Type/Row/Homogeneous.purs

@@ -1,6 +1,6 @@
 module Type.Row.Homogeneous
   ( class Homogeneous
-  , class HomogenousRowList
+  , class HomogeneousRowList
   ) where
 
 import Type.Equality (class TypeEquals)
@@ -10,12 +10,12 @@ import Type.Row (class RowToList, Cons, Nil, kind RowList)
 class Homogeneous (row :: # Type) fieldType | row -> fieldType
 instance homogeneous
   :: ( RowToList row fields
-     , HomogenousRowList fields fieldType )
+     , HomogeneousRowList fields fieldType )
   => Homogeneous row fieldType
 
-class HomogenousRowList (rowList :: RowList) fieldType | rowList -> fieldType
-instance homogenousRowListCons
-  :: ( HomogenousRowList tail fieldType
+class HomogeneousRowList (rowList :: RowList) fieldType | rowList -> fieldType
+instance homogeneousRowListCons
+  :: ( HomogeneousRowList tail fieldType
      , TypeEquals fieldType fieldType2 )
-  => HomogenousRowList (Cons symbol fieldType tail) fieldType2
-instance homogenousRowListNil :: HomogenousRowList Nil fieldType
+  => HomogeneousRowList (Cons symbol fieldType tail) fieldType2
+instance homogeneousRowListNil :: HomogeneousRowList Nil fieldType