staging release/M1h

.mergify.yml

@@ -0,0 +1,13 @@
+pull_request_rules:
+  - name: automatic merge on CI success and review
+    conditions:
+      - status-success=continuous-integration/travis-ci/pr
+      - label=ready-to-merge
+      - "#approved-reviews-by>=1"
+    actions:
+      merge:
+        method: merge
+#   - name: delete head branch after merge
+#     conditions: []
+#     actions:
+#       delete_head_branch: {}

.travis.yml

@@ -24,4 +24,5 @@ install:
 - stack --no-terminal exec tests
 - stack --no-terminal exec transcripts
 # fail if running transcripts modified any versioned files
-- x=`git status --porcelain -uno` bash -c 'if [[ -n $x ]]; then echo "$x" && false; fi' 
+- git diff
+- x=`git status --porcelain -uno` bash -c 'if [[ -n $x ]]; then echo "$x" && false; fi'

CONTRIBUTORS.markdown

@@ -30,4 +30,9 @@ The format for this list: name, GitHub handle, and then optional blurb about wha
 * Jonas De Vuyst (@jdevuyst)
 * George Marrows (@georgemarrows)
 * Florian Thurm (@0xflotus)
+* Mat Ess (@matthewess)
 * Evan Burchard (@evanburchard)
+* Alvaro Carrasco (@alvaroc1)
+* Vladislav Zavialov (@int-index)
+* Aaron Novstrup (@anovstrup)
+* Pete Tsamouris (@pete-ts)

parser-typechecker/src/Unison/Builtin.hs

@@ -11,6 +11,7 @@ module Unison.Builtin
   ,names0
   ,builtinDataDecls
   ,builtinEffectDecls
+  ,builtinConstructorType
   ,builtinTypeDependents
   ,builtinTermsByType
   ,builtinTermsByTypeMention
@@ -75,7 +76,8 @@ typeLookup =
     (Map.fromList $ map snd builtinEffectDecls)
 
 constructorType :: R.Reference -> Maybe CT.ConstructorType
-constructorType = TL.constructorType (typeLookup @Symbol)
+constructorType r = TL.constructorType (typeLookup @Symbol) r
+                <|> Map.lookup r builtinConstructorType
 
 -- | parse some builtin data types, and resolve their free variables using
 -- | builtinTypes' and those types defined herein
@@ -122,7 +124,7 @@ builtinTypes :: [(Name, R.Reference)]
 builtinTypes = Map.toList . Map.mapKeys Name.unsafeFromText
                           $ foldl' go mempty builtinTypesSrc where
   go m = \case
-    B' r -> Map.insert r (R.Builtin r) m
+    B' r _ -> Map.insert r (R.Builtin r) m
     D' r -> Map.insert r (R.Builtin r) m
     Rename' r name -> case Map.lookup name m of
       Just _ -> error . Text.unpack $
@@ -144,21 +146,23 @@ builtinTypes = Map.toList . Map.mapKeys Name.unsafeFromText
 -- WARNING: Don't delete any of these lines, only add corrections.
 builtinTypesSrc :: [BuiltinTypeDSL]
 builtinTypesSrc =
-  [ B' "Int"
-  , B' "Nat"
-  , B' "Float"
-  , B' "Boolean"
-  , B' "Sequence", Rename' "Sequence" "List"
-  , B' "Text"
-  , B' "Char"
-  , B' "Effect", Rename' "Effect" "Request"
-  , B' "Bytes"
-  , B' "Link.Term"
-  , B' "Link.Type"
+  [ B' "Int" CT.Data
+  , B' "Nat" CT.Data
+  , B' "Float" CT.Data
+  , B' "Boolean" CT.Data
+  , B' "Sequence" CT.Data, Rename' "Sequence" "List"
+  , B' "Text" CT.Data
+  , B' "Char" CT.Data
+  , B' "Effect" CT.Data, Rename' "Effect" "Request"
+  , B' "Bytes" CT.Data
+  , B' "Link.Term" CT.Data
+  , B' "Link.Type" CT.Data
   ]
 
+builtinConstructorType :: Map R.Reference CT.ConstructorType
+builtinConstructorType = Map.fromList [ (R.Builtin r, ct) | B' r ct <- builtinTypesSrc ]
 
-data BuiltinTypeDSL = B' Text | D' Text | Rename' Text Text | Alias' Text Text
+data BuiltinTypeDSL = B' Text CT.ConstructorType | D' Text | Rename' Text Text | Alias' Text Text
 
 
 data BuiltinDSL v
@@ -309,6 +313,9 @@ builtinsSrc =
   , B "Universal.>=" $ forall1 "a" (\a -> a --> a --> boolean)
   , B "Universal.<=" $ forall1 "a" (\a -> a --> a --> boolean)
 
+  , B "bug" $ forall1 "a" (\a -> forall1 "b" (\b -> a --> b))
+  , B "todo" $ forall1 "a" (\a -> forall1 "b" (\b -> a --> b))
+
   , B "Boolean.not" $ boolean --> boolean
 
   , B "Text.empty" text

parser-typechecker/src/Unison/Codebase.hs

@@ -17,7 +17,7 @@ import qualified Unison.Codebase.Branch        as Branch
 import qualified Unison.Codebase.CodeLookup    as CL
 import qualified Unison.Codebase.Reflog        as Reflog
 import qualified Unison.DataDeclaration        as DD
-import           Unison.Name                    ( Name(..) )
+import qualified Unison.Name                   as Name
 import qualified Unison.Names2                 as Names
 import           Unison.Reference               ( Reference )
 import qualified Unison.Reference              as Reference
@@ -89,8 +89,8 @@ data Codebase m v a =
            , branchHashesByPrefix :: ShortBranchHash -> m (Set Branch.Hash)
            }
 
-bootstrapNames :: Names.Names0 
-bootstrapNames = 
+bootstrapNames :: Names.Names0
+bootstrapNames =
   Builtin.names0 <> UF.typecheckedToNames0 IOSource.typecheckedFile
 
 -- | Write all of the builtins types and IO types into the codebase. Returns the names of builtins
@@ -110,7 +110,7 @@ initializeCodebase :: forall m. Monad m => Codebase m Symbol Parser.Ann -> m ()
 initializeCodebase c = do
   initializeBuiltinCode c
   let b0 = BranchUtil.addFromNames0
-            (Names.prefix0 (Name "builtin") bootstrapNames)
+            (Names.prefix0 (Name.unsafeFromText "builtin") bootstrapNames)
             Branch.empty0
   putRootBranch c (Branch.one b0)
 
@@ -129,7 +129,7 @@ addDefsToCodebase c uf = do
     goType :: (t -> Decl v a) -> (Reference.Reference, t) -> m ()
     goType f (ref, decl) = case ref of
       Reference.DerivedId id -> putTypeDeclaration c id (f decl)
-      _                      -> pure ()
+      Reference.Builtin{}    -> pure ()
 
 getTypeOfConstructor ::
   (Monad m, Ord v) => Codebase m v a -> Reference -> Int -> m (Maybe (Type v a))
@@ -155,7 +155,7 @@ typeLookupForDependencies codebase = foldM go mempty
         Just (Right dd) ->
           pure $ TypeLookup mempty (Map.singleton ref dd) mempty
         Nothing -> pure mempty
-  go tl _builtin = pure tl -- codebase isn't consulted for builtins
+  go tl Reference.Builtin{} = pure tl -- codebase isn't consulted for builtins
 
 -- todo: can this be implemented in terms of TransitiveClosure.transitiveClosure?
 -- todo: add some tests on this guy?
@@ -186,7 +186,7 @@ transitiveDependencies code seen0 r = if Set.member r seen0
                 Just (Right dd) -> foldM (transitiveDependencies code)
                                          seen
                                          (DD.dependencies dd)
-        _ -> pure seen
+        Reference.Builtin{} -> pure seen
 
 toCodeLookup :: Codebase m v a -> CL.CodeLookup v m a
 toCodeLookup c = CL.CodeLookup (getTerm c) (getTypeDeclaration c)
@@ -205,12 +205,12 @@ makeSelfContained' code uf = do
   deps <- foldM (transitiveDependencies code) Set.empty (Set.unions deps0)
   decls <- fmap catMaybes . forM (toList deps) $ \case
     r@(Reference.DerivedId rid) -> fmap (r, ) <$> CL.getTypeDeclaration code rid
-    _                           -> pure Nothing
+    Reference.Builtin{}         -> pure Nothing
   let (es1, ds1) = partitionEithers [ bimap (r,) (r,) d | (r, d) <- decls ]
   bs1 <- fmap catMaybes . forM (toList deps) $ \case
     r@(Reference.DerivedId rid) ->
       fmap (r, ) <$> CL.getTerm code rid
-    _ -> pure Nothing
+    Reference.Builtin{} -> pure Nothing
   let
     allVars = Set.unions
       [ UF.allVars uf