Retire raise command (#407)

- remove `raise` command
- rename `error` to `fail` - should suggest both that it is:
  - recoverable - can be caught with `try`
  - pure - `fail: string -> a` - so it can be used outside `cmd`

---

The problem with `raise` was that it was merely a specialized version of `error` (which was not limited to `cmd a`):
```
let raised: string -> cmd a = error in raised "ha"
```
I noticed this while making the list for #26.

On a meta-level, it also conflicts with the `raise` Haskell function we use to throw an error when a command (like `build`) fails.

example/list.sw

@@ -203,7 +203,7 @@ end
 
 // TODO: show values when #248 is implemented
 def assert = \b.\m.
-  if b {} {log "FAIL:"; raise m}
+  if b {} {log "FAIL:"; fail m}
 end
 
 def testLIST =

src/Swarm/Game/Exception.hs

@@ -71,7 +71,7 @@ data Exn
     --   command could not move, or a 'Grab' command found nothing to
     --   grab, /etc./).
     CmdFailed Const Text
-  | -- | The user program explicitly called 'Raise', 'Undefined', or 'ErrorStr'.
+  | -- | The user program explicitly called 'Undefined' or 'Fail'.
     User Text
   deriving (Eq, Show)
 

src/Swarm/Game/Step.hs

@@ -1171,11 +1171,8 @@ execConst c vs s k = do
     Try -> case vs of
       [c1, c2] -> return $ Out c1 s (FApp (VCApp Force []) : FExec : FTry c2 : k)
       _ -> badConst
-    Raise -> case vs of
-      [VString msg] -> return $ Up (User msg) s k
-      _ -> badConst
     Undefined -> return $ Up (User "undefined") s k
-    ErrorStr -> case vs of
+    Fail -> case vs of
       [VString msg] -> return $ Up (User msg) s k
       _ -> badConst
     Reprogram -> case vs of

src/Swarm/Language/Capability.hs

@@ -263,7 +263,7 @@ constCaps =
     Base -> []
     Setname -> []
     Undefined -> []
-    ErrorStr -> []
+    Fail -> []
     -- Some straightforward ones.
     Log -> [CLog]
     Selfdestruct -> [CSelfdestruct]
@@ -330,6 +330,5 @@ constCaps =
     Case -> []
     Fst -> [] -- XXX should require cap for pairs
     Snd -> []
-    Try -> [] -- XXX these definitely need to require
-    Raise -> [] -- something.
+    Try -> [] -- XXX these definitely need to require something.
     Knows -> []

src/Swarm/Language/Parse.hs

@@ -213,7 +213,7 @@ parseDirection = asum (map alternative allDirs) <?> "direction constant"
  where
   alternative d = d <$ (reserved . dirSyntax . dirInfo) d
 
--- | Parse Const as reserved words (e.g. @Raise <$ reserved "raise"@)
+-- | Parse Const as reserved words (e.g. @Fail <$ reserved "fail"@)
 parseConst :: Parser Const
 parseConst = asum (map alternative consts) <?> "built-in user function"
  where

src/Swarm/Language/Syntax.hs

@@ -294,12 +294,10 @@ data Const
     Return
   | -- | Try/catch block
     Try
-  | -- | Raise an exception
-    Raise
   | -- | Undefined
     Undefined
-  | -- | Error
-    ErrorStr
+  | -- | User error
+    Fail
   | -- Arithmetic unary operators
 
     -- | Logical negation.
@@ -467,9 +465,8 @@ constInfo c = case c of
   Run -> commandLow 1
   Return -> commandLow 1
   Try -> commandLow 2
-  Raise -> commandLow 1
   Undefined -> functionLow 0
-  ErrorStr -> function "error" 1
+  Fail -> functionLow 1
   If -> functionLow 3
   Inl -> functionLow 1
   Inr -> functionLow 1

src/Swarm/Language/Typecheck.hs

@@ -476,9 +476,8 @@ inferConst c = toU $ case c of
   Force -> [tyQ| {a} -> a |]
   Return -> [tyQ| a -> cmd a |]
   Try -> [tyQ| {cmd a} -> {cmd a} -> cmd a |]
-  Raise -> [tyQ| string -> cmd a |]
   Undefined -> [tyQ| a |]
-  ErrorStr -> [tyQ| string -> a |]
+  Fail -> [tyQ| string -> a |]
   Not -> [tyQ| bool -> bool |]
   Neg -> [tyQ| int -> int |]
   Eq -> cmpBinT

test/unit/Main.hs

@@ -409,20 +409,20 @@ eval g =
     , testGroup
         "exceptions"
         [ testCase
-            "raise"
-            ("raise \"foo\"" `throwsError` ("foo" `T.isInfixOf`))
+            "fail"
+            ("fail \"foo\"" `throwsError` ("foo" `T.isInfixOf`))
         , testCase
             "try / no exception 1"
             ("try {return 1} {return 2}" `evaluatesTo` VInt 1)
         , testCase
             "try / no exception 2"
             ("try {return 1} {let x = x in x}" `evaluatesTo` VInt 1)
         , testCase
-            "try / raise"
-            ("try {raise \"foo\"} {return 3}" `evaluatesTo` VInt 3)
+            "try / fail"
+            ("try {fail \"foo\"} {return 3}" `evaluatesTo` VInt 3)
         , testCase
-            "try / raise / raise"
-            ("try {raise \"foo\"} {raise \"bar\"}" `throwsError` ("bar" `T.isInfixOf`))
+            "try / fail / fail"
+            ("try {fail \"foo\"} {fail \"bar\"}" `throwsError` ("bar" `T.isInfixOf`))
         , testCase
             "try / div by 0"
             ("try {return (1/0)} {return 3}" `evaluatesTo` VInt 3)