{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}

-- |
-- SPDX-License-Identifier: BSD-3-Clause
--
-- Types representing the surface syntax and terms for Swarm programming language.
module Swarm.Language.Syntax.AST (
  Syntax' (..),
  LetSyntax (..),
  Term' (..),
) where

import Control.Lens (Plated (..))
import Data.Aeson.Types hiding (Key)
import Data.Data (Data)
import Data.Data.Lens (uniplate)
import Data.Hashable (Hashable)
import Data.Map.Strict (Map)
import Data.Text (Text)
import GHC.Generics (Generic)
import Swarm.Language.Requirements.Type (Requirements)
import Swarm.Language.Syntax.Comments
import Swarm.Language.Syntax.Constants
import Swarm.Language.Syntax.Direction
import Swarm.Language.Syntax.Loc
import Swarm.Language.TDVar (TDVar)
import Swarm.Language.Types

------------------------------------------------------------
-- Syntax: annotation on top of Terms with SrcLoc, comments, + type
------------------------------------------------------------

-- | The surface syntax for the language, with location and type annotations.
data Syntax' ty = Syntax'
  { forall ty. Syntax' ty -> SrcLoc
_sLoc :: SrcLoc
  , forall ty. Syntax' ty -> Term' ty
_sTerm :: Term' ty
  , forall ty. Syntax' ty -> Comments
_sComments :: Comments
  , forall ty. Syntax' ty -> ty
_sType :: ty
  }
  deriving (Syntax' ty -> Syntax' ty -> Bool
(Syntax' ty -> Syntax' ty -> Bool)
-> (Syntax' ty -> Syntax' ty -> Bool) -> Eq (Syntax' ty)
forall ty. Eq ty => Syntax' ty -> Syntax' ty -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall ty. Eq ty => Syntax' ty -> Syntax' ty -> Bool
== :: Syntax' ty -> Syntax' ty -> Bool
$c/= :: forall ty. Eq ty => Syntax' ty -> Syntax' ty -> Bool
/= :: Syntax' ty -> Syntax' ty -> Bool
Eq, Int -> Syntax' ty -> ShowS
[Syntax' ty] -> ShowS
Syntax' ty -> String
(Int -> Syntax' ty -> ShowS)
-> (Syntax' ty -> String)
-> ([Syntax' ty] -> ShowS)
-> Show (Syntax' ty)
forall ty. Show ty => Int -> Syntax' ty -> ShowS
forall ty. Show ty => [Syntax' ty] -> ShowS
forall ty. Show ty => Syntax' ty -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall ty. Show ty => Int -> Syntax' ty -> ShowS
showsPrec :: Int -> Syntax' ty -> ShowS
$cshow :: forall ty. Show ty => Syntax' ty -> String
show :: Syntax' ty -> String
$cshowList :: forall ty. Show ty => [Syntax' ty] -> ShowS
showList :: [Syntax' ty] -> ShowS
Show, (forall a b. (a -> b) -> Syntax' a -> Syntax' b)
-> (forall a b. a -> Syntax' b -> Syntax' a) -> Functor Syntax'
forall a b. a -> Syntax' b -> Syntax' a
forall a b. (a -> b) -> Syntax' a -> Syntax' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Syntax' a -> Syntax' b
fmap :: forall a b. (a -> b) -> Syntax' a -> Syntax' b
$c<$ :: forall a b. a -> Syntax' b -> Syntax' a
<$ :: forall a b. a -> Syntax' b -> Syntax' a
Functor, (forall m. Monoid m => Syntax' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Syntax' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Syntax' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Syntax' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Syntax' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Syntax' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Syntax' a -> b)
-> (forall a. (a -> a -> a) -> Syntax' a -> a)
-> (forall a. (a -> a -> a) -> Syntax' a -> a)
-> (forall a. Syntax' a -> [a])
-> (forall a. Syntax' a -> Bool)
-> (forall a. Syntax' a -> Int)
-> (forall a. Eq a => a -> Syntax' a -> Bool)
-> (forall a. Ord a => Syntax' a -> a)
-> (forall a. Ord a => Syntax' a -> a)
-> (forall a. Num a => Syntax' a -> a)
-> (forall a. Num a => Syntax' a -> a)
-> Foldable Syntax'
forall a. Eq a => a -> Syntax' a -> Bool
forall a. Num a => Syntax' a -> a
forall a. Ord a => Syntax' a -> a
forall m. Monoid m => Syntax' m -> m
forall a. Syntax' a -> Bool
forall a. Syntax' a -> Int
forall a. Syntax' a -> [a]
forall a. (a -> a -> a) -> Syntax' a -> a
forall m a. Monoid m => (a -> m) -> Syntax' a -> m
forall b a. (b -> a -> b) -> b -> Syntax' a -> b
forall a b. (a -> b -> b) -> b -> Syntax' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Syntax' m -> m
fold :: forall m. Monoid m => Syntax' m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Syntax' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Syntax' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Syntax' a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Syntax' a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Syntax' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Syntax' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Syntax' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Syntax' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Syntax' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Syntax' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Syntax' a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Syntax' a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Syntax' a -> a
foldr1 :: forall a. (a -> a -> a) -> Syntax' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Syntax' a -> a
foldl1 :: forall a. (a -> a -> a) -> Syntax' a -> a
$ctoList :: forall a. Syntax' a -> [a]
toList :: forall a. Syntax' a -> [a]
$cnull :: forall a. Syntax' a -> Bool
null :: forall a. Syntax' a -> Bool
$clength :: forall a. Syntax' a -> Int
length :: forall a. Syntax' a -> Int
$celem :: forall a. Eq a => a -> Syntax' a -> Bool
elem :: forall a. Eq a => a -> Syntax' a -> Bool
$cmaximum :: forall a. Ord a => Syntax' a -> a
maximum :: forall a. Ord a => Syntax' a -> a
$cminimum :: forall a. Ord a => Syntax' a -> a
minimum :: forall a. Ord a => Syntax' a -> a
$csum :: forall a. Num a => Syntax' a -> a
sum :: forall a. Num a => Syntax' a -> a
$cproduct :: forall a. Num a => Syntax' a -> a
product :: forall a. Num a => Syntax' a -> a
Foldable, Functor Syntax'
Foldable Syntax'
(Functor Syntax', Foldable Syntax') =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Syntax' a -> f (Syntax' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Syntax' (f a) -> f (Syntax' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Syntax' a -> m (Syntax' b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Syntax' (m a) -> m (Syntax' a))
-> Traversable Syntax'
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Syntax' (m a) -> m (Syntax' a)
forall (f :: * -> *) a.
Applicative f =>
Syntax' (f a) -> f (Syntax' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Syntax' a -> m (Syntax' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Syntax' a -> f (Syntax' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Syntax' a -> f (Syntax' b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Syntax' a -> f (Syntax' b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Syntax' (f a) -> f (Syntax' a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Syntax' (f a) -> f (Syntax' a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Syntax' a -> m (Syntax' b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Syntax' a -> m (Syntax' b)
$csequence :: forall (m :: * -> *) a. Monad m => Syntax' (m a) -> m (Syntax' a)
sequence :: forall (m :: * -> *) a. Monad m => Syntax' (m a) -> m (Syntax' a)
Traversable, Typeable (Syntax' ty)
Typeable (Syntax' ty) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Syntax' ty))
-> (Syntax' ty -> Constr)
-> (Syntax' ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Syntax' ty)))
-> ((forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Syntax' ty -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty))
-> Data (Syntax' ty)
Syntax' ty -> Constr
Syntax' ty -> DataType
(forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty
forall ty. Data ty => Typeable (Syntax' ty)
forall ty. Data ty => Syntax' ty -> Constr
forall ty. Data ty => Syntax' ty -> DataType
forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty
forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u
forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Syntax' ty -> [u]
forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Syntax' ty)
forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty)
forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty))
forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Syntax' ty))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u
forall u. (forall d. Data d => d -> u) -> Syntax' ty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Syntax' ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Syntax' ty))
$cgfoldl :: forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty)
$cgunfold :: forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Syntax' ty)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Syntax' ty)
$ctoConstr :: forall ty. Data ty => Syntax' ty -> Constr
toConstr :: Syntax' ty -> Constr
$cdataTypeOf :: forall ty. Data ty => Syntax' ty -> DataType
dataTypeOf :: Syntax' ty -> DataType
$cdataCast1 :: forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty))
$cdataCast2 :: forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Syntax' ty))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Syntax' ty))
$cgmapT :: forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty
gmapT :: (forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty
$cgmapQl :: forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
$cgmapQr :: forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r
$cgmapQ :: forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Syntax' ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Syntax' ty -> [u]
$cgmapQi :: forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u
$cgmapM :: forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
$cgmapMp :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
$cgmapMo :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)
Data, (forall x. Syntax' ty -> Rep (Syntax' ty) x)
-> (forall x. Rep (Syntax' ty) x -> Syntax' ty)
-> Generic (Syntax' ty)
forall x. Rep (Syntax' ty) x -> Syntax' ty
forall x. Syntax' ty -> Rep (Syntax' ty) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ty x. Rep (Syntax' ty) x -> Syntax' ty
forall ty x. Syntax' ty -> Rep (Syntax' ty) x
$cfrom :: forall ty x. Syntax' ty -> Rep (Syntax' ty) x
from :: forall x. Syntax' ty -> Rep (Syntax' ty) x
$cto :: forall ty x. Rep (Syntax' ty) x -> Syntax' ty
to :: forall x. Rep (Syntax' ty) x -> Syntax' ty
Generic, Eq (Syntax' ty)
Eq (Syntax' ty) =>
(Int -> Syntax' ty -> Int)
-> (Syntax' ty -> Int) -> Hashable (Syntax' ty)
Int -> Syntax' ty -> Int
Syntax' ty -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ty. Hashable ty => Eq (Syntax' ty)
forall ty. Hashable ty => Int -> Syntax' ty -> Int
forall ty. Hashable ty => Syntax' ty -> Int
$chashWithSalt :: forall ty. Hashable ty => Int -> Syntax' ty -> Int
hashWithSalt :: Int -> Syntax' ty -> Int
$chash :: forall ty. Hashable ty => Syntax' ty -> Int
hash :: Syntax' ty -> Int
Hashable)

instance Data ty => Plated (Syntax' ty) where
  plate :: Traversal' (Syntax' ty) (Syntax' ty)
plate = (Syntax' ty -> f (Syntax' ty)) -> Syntax' ty -> f (Syntax' ty)
forall a. Data a => Traversal' a a
Traversal' (Syntax' ty) (Syntax' ty)
uniplate

-- | A @let@ expression can be written either as @let x = e1 in e2@ or
--   as @def x = e1 end; e2@. This enumeration simply records which it
--   was so that we can pretty-print appropriately.
data LetSyntax = LSLet | LSDef
  deriving (LetSyntax -> LetSyntax -> Bool
(LetSyntax -> LetSyntax -> Bool)
-> (LetSyntax -> LetSyntax -> Bool) -> Eq LetSyntax
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LetSyntax -> LetSyntax -> Bool
== :: LetSyntax -> LetSyntax -> Bool
$c/= :: LetSyntax -> LetSyntax -> Bool
/= :: LetSyntax -> LetSyntax -> Bool
Eq, Eq LetSyntax
Eq LetSyntax =>
(LetSyntax -> LetSyntax -> Ordering)
-> (LetSyntax -> LetSyntax -> Bool)
-> (LetSyntax -> LetSyntax -> Bool)
-> (LetSyntax -> LetSyntax -> Bool)
-> (LetSyntax -> LetSyntax -> Bool)
-> (LetSyntax -> LetSyntax -> LetSyntax)
-> (LetSyntax -> LetSyntax -> LetSyntax)
-> Ord LetSyntax
LetSyntax -> LetSyntax -> Bool
LetSyntax -> LetSyntax -> Ordering
LetSyntax -> LetSyntax -> LetSyntax
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LetSyntax -> LetSyntax -> Ordering
compare :: LetSyntax -> LetSyntax -> Ordering
$c< :: LetSyntax -> LetSyntax -> Bool
< :: LetSyntax -> LetSyntax -> Bool
$c<= :: LetSyntax -> LetSyntax -> Bool
<= :: LetSyntax -> LetSyntax -> Bool
$c> :: LetSyntax -> LetSyntax -> Bool
> :: LetSyntax -> LetSyntax -> Bool
$c>= :: LetSyntax -> LetSyntax -> Bool
>= :: LetSyntax -> LetSyntax -> Bool
$cmax :: LetSyntax -> LetSyntax -> LetSyntax
max :: LetSyntax -> LetSyntax -> LetSyntax
$cmin :: LetSyntax -> LetSyntax -> LetSyntax
min :: LetSyntax -> LetSyntax -> LetSyntax
Ord, Int -> LetSyntax -> ShowS
[LetSyntax] -> ShowS
LetSyntax -> String
(Int -> LetSyntax -> ShowS)
-> (LetSyntax -> String)
-> ([LetSyntax] -> ShowS)
-> Show LetSyntax
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LetSyntax -> ShowS
showsPrec :: Int -> LetSyntax -> ShowS
$cshow :: LetSyntax -> String
show :: LetSyntax -> String
$cshowList :: [LetSyntax] -> ShowS
showList :: [LetSyntax] -> ShowS
Show, LetSyntax
LetSyntax -> LetSyntax -> Bounded LetSyntax
forall a. a -> a -> Bounded a
$cminBound :: LetSyntax
minBound :: LetSyntax
$cmaxBound :: LetSyntax
maxBound :: LetSyntax
Bounded, Int -> LetSyntax
LetSyntax -> Int
LetSyntax -> [LetSyntax]
LetSyntax -> LetSyntax
LetSyntax -> LetSyntax -> [LetSyntax]
LetSyntax -> LetSyntax -> LetSyntax -> [LetSyntax]
(LetSyntax -> LetSyntax)
-> (LetSyntax -> LetSyntax)
-> (Int -> LetSyntax)
-> (LetSyntax -> Int)
-> (LetSyntax -> [LetSyntax])
-> (LetSyntax -> LetSyntax -> [LetSyntax])
-> (LetSyntax -> LetSyntax -> [LetSyntax])
-> (LetSyntax -> LetSyntax -> LetSyntax -> [LetSyntax])
-> Enum LetSyntax
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: LetSyntax -> LetSyntax
succ :: LetSyntax -> LetSyntax
$cpred :: LetSyntax -> LetSyntax
pred :: LetSyntax -> LetSyntax
$ctoEnum :: Int -> LetSyntax
toEnum :: Int -> LetSyntax
$cfromEnum :: LetSyntax -> Int
fromEnum :: LetSyntax -> Int
$cenumFrom :: LetSyntax -> [LetSyntax]
enumFrom :: LetSyntax -> [LetSyntax]
$cenumFromThen :: LetSyntax -> LetSyntax -> [LetSyntax]
enumFromThen :: LetSyntax -> LetSyntax -> [LetSyntax]
$cenumFromTo :: LetSyntax -> LetSyntax -> [LetSyntax]
enumFromTo :: LetSyntax -> LetSyntax -> [LetSyntax]
$cenumFromThenTo :: LetSyntax -> LetSyntax -> LetSyntax -> [LetSyntax]
enumFromThenTo :: LetSyntax -> LetSyntax -> LetSyntax -> [LetSyntax]
Enum, (forall x. LetSyntax -> Rep LetSyntax x)
-> (forall x. Rep LetSyntax x -> LetSyntax) -> Generic LetSyntax
forall x. Rep LetSyntax x -> LetSyntax
forall x. LetSyntax -> Rep LetSyntax x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LetSyntax -> Rep LetSyntax x
from :: forall x. LetSyntax -> Rep LetSyntax x
$cto :: forall x. Rep LetSyntax x -> LetSyntax
to :: forall x. Rep LetSyntax x -> LetSyntax
Generic, Typeable LetSyntax
Typeable LetSyntax =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LetSyntax -> c LetSyntax)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LetSyntax)
-> (LetSyntax -> Constr)
-> (LetSyntax -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LetSyntax))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetSyntax))
-> ((forall b. Data b => b -> b) -> LetSyntax -> LetSyntax)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LetSyntax -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LetSyntax -> r)
-> (forall u. (forall d. Data d => d -> u) -> LetSyntax -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LetSyntax -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax)
-> Data LetSyntax
LetSyntax -> Constr
LetSyntax -> DataType
(forall b. Data b => b -> b) -> LetSyntax -> LetSyntax
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LetSyntax -> u
forall u. (forall d. Data d => d -> u) -> LetSyntax -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetSyntax
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetSyntax -> c LetSyntax
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetSyntax)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetSyntax)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetSyntax -> c LetSyntax
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetSyntax -> c LetSyntax
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetSyntax
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetSyntax
$ctoConstr :: LetSyntax -> Constr
toConstr :: LetSyntax -> Constr
$cdataTypeOf :: LetSyntax -> DataType
dataTypeOf :: LetSyntax -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetSyntax)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetSyntax)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetSyntax)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetSyntax)
$cgmapT :: (forall b. Data b => b -> b) -> LetSyntax -> LetSyntax
gmapT :: (forall b. Data b => b -> b) -> LetSyntax -> LetSyntax
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetSyntax -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LetSyntax -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LetSyntax -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetSyntax -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetSyntax -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax
Data, Eq LetSyntax
Eq LetSyntax =>
(Int -> LetSyntax -> Int)
-> (LetSyntax -> Int) -> Hashable LetSyntax
Int -> LetSyntax -> Int
LetSyntax -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> LetSyntax -> Int
hashWithSalt :: Int -> LetSyntax -> Int
$chash :: LetSyntax -> Int
hash :: LetSyntax -> Int
Hashable, [LetSyntax] -> Value
[LetSyntax] -> Encoding
LetSyntax -> Bool
LetSyntax -> Value
LetSyntax -> Encoding
(LetSyntax -> Value)
-> (LetSyntax -> Encoding)
-> ([LetSyntax] -> Value)
-> ([LetSyntax] -> Encoding)
-> (LetSyntax -> Bool)
-> ToJSON LetSyntax
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: LetSyntax -> Value
toJSON :: LetSyntax -> Value
$ctoEncoding :: LetSyntax -> Encoding
toEncoding :: LetSyntax -> Encoding
$ctoJSONList :: [LetSyntax] -> Value
toJSONList :: [LetSyntax] -> Value
$ctoEncodingList :: [LetSyntax] -> Encoding
toEncodingList :: [LetSyntax] -> Encoding
$comitField :: LetSyntax -> Bool
omitField :: LetSyntax -> Bool
ToJSON, Maybe LetSyntax
Value -> Parser [LetSyntax]
Value -> Parser LetSyntax
(Value -> Parser LetSyntax)
-> (Value -> Parser [LetSyntax])
-> Maybe LetSyntax
-> FromJSON LetSyntax
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser LetSyntax
parseJSON :: Value -> Parser LetSyntax
$cparseJSONList :: Value -> Parser [LetSyntax]
parseJSONList :: Value -> Parser [LetSyntax]
$comittedField :: Maybe LetSyntax
omittedField :: Maybe LetSyntax
FromJSON)

------------------------------------------------------------
-- Term: basic syntax tree
------------------------------------------------------------

-- | Terms of the Swarm language.
data Term' ty
  = -- | The unit value.
    TUnit
  | -- | A constant.
    TConst Const
  | -- | A direction literal.
    TDir Direction
  | -- | An integer literal.
    TInt Integer
  | -- | An antiquoted Haskell variable name of type Integer.
    TAntiInt Text
  | -- | A text literal.
    TText Text
  | -- | An antiquoted Haskell variable name of type Text.
    TAntiText Text
  | -- | A Boolean literal.
    TBool Bool
  | -- | An antiquoted Haskell variable name of type Syntax.
    TAntiSyn Text
  | -- | A robot reference.  These never show up in surface syntax, but are
    --   here so we can factor pretty-printing for Values through
    --   pretty-printing for Terms.
    TRobot Int
  | -- | A memory reference.  These likewise never show up in surface syntax,
    --   but are here to facilitate pretty-printing.
    TRef Int
  | -- | Require a specific device to be installed.
    TRequire Text
  | -- | Require a certain number of an entity.
    TStock Int Text
  | -- | Primitive command to log requirements of a term.  The Text
    --   field is to store the unaltered original text of the term, for use
    --   in displaying the log message (since once we get to execution time the
    --   original term may have been elaborated, e.g. `force` may have been added
    --   around some variables, etc.)
    SRequirements Text (Syntax' ty)
  | -- | A variable.
    TVar Var
  | -- | A pair.
    SPair (Syntax' ty) (Syntax' ty)
  | -- | A lambda expression, with or without a type annotation on the
    --   binder.
    SLam LocVar (Maybe Type) (Syntax' ty)
  | -- | Function application.
    SApp (Syntax' ty) (Syntax' ty)
  | -- | A (recursive) let/def expression, with or without a type
    --   annotation on the variable. The @Bool@ indicates whether
    --   it is known to be recursive.
    --
    --   The @Maybe Polytype@ and @Maybe Requirements@ fields are only
    --   for annotating the requirements of a definition after
    --   typechecking; there is no way to annotate requirements in the
    --   surface syntax.
    SLet LetSyntax Bool LocVar (Maybe RawPolytype) (Maybe Polytype) (Maybe Requirements) (Syntax' ty) (Syntax' ty)
  | -- | A type synonym definition.  Note that this acts like a @let@
    --   (just like @def@), /i.e./ the @Syntax' ty@ field is the local
    --   context over which the type definition is in scope.
    STydef (Located TDVar) Polytype (Maybe TydefInfo) (Syntax' ty)
  | -- | A monadic bind for commands, of the form @c1 ; c2@ or @x <- c1; c2@.
    --
    --   The @Maybe ty@ field is a place to stash the inferred type of
    --   the variable (if any) during type inference.  Once type
    --   inference is complete, during elaboration we will copy the
    --   inferred type into the @Maybe Polytype@ field (since the
    --   @Maybe ty@ field will be erased).
    --
    --   The @Maybe Polytype@ and @Maybe Requirements@ fields is only
    --   for annotating the type of a bind after typechecking; there
    --   is no surface syntax that allows directly annotating a bind
    --   with either one.
    SBind (Maybe LocVar) (Maybe ty) (Maybe Polytype) (Maybe Requirements) (Syntax' ty) (Syntax' ty)
  | -- | Delay evaluation of a term, written @{...}@.  Swarm is an
    --   eager language, but in some cases (e.g. for @if@ statements
    --   and recursive bindings) we need to delay evaluation.  The
    --   counterpart to @{...}@ is @force@, where @force {t} = t@.
    --   Note that 'Force' is just a constant, whereas 'SDelay' has to
    --   be a special syntactic form so its argument can get special
    --   treatment during evaluation.
    SDelay (Syntax' ty)
  | -- | Record literals @[x1 = e1, x2 = e2, x3, ...]@ Names @x@
    --   without an accompanying definition are sugar for writing
    --   @x=x@.
    SRcd (Map Var (Maybe (Syntax' ty)))
  | -- | Record projection @e.x@
    SProj (Syntax' ty) Var
  | -- | Annotate a term with a type
    SAnnotate (Syntax' ty) RawPolytype
  | -- | Run the given command, then suspend and wait for a new REPL
    --   input.
    SSuspend (Syntax' ty)
  | -- | An explicit representation of parentheses in the input.  We
    --   need this to be able to print formatted code with parentheses
    --   and comments preserved, but we get rid of them during
    --   elaboration.
    SParens (Syntax' ty)
  | -- | A type literal.
    TType Type
  deriving
    ( Term' ty -> Term' ty -> Bool
(Term' ty -> Term' ty -> Bool)
-> (Term' ty -> Term' ty -> Bool) -> Eq (Term' ty)
forall ty. Eq ty => Term' ty -> Term' ty -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall ty. Eq ty => Term' ty -> Term' ty -> Bool
== :: Term' ty -> Term' ty -> Bool
$c/= :: forall ty. Eq ty => Term' ty -> Term' ty -> Bool
/= :: Term' ty -> Term' ty -> Bool
Eq
    , Int -> Term' ty -> ShowS
[Term' ty] -> ShowS
Term' ty -> String
(Int -> Term' ty -> ShowS)
-> (Term' ty -> String) -> ([Term' ty] -> ShowS) -> Show (Term' ty)
forall ty. Show ty => Int -> Term' ty -> ShowS
forall ty. Show ty => [Term' ty] -> ShowS
forall ty. Show ty => Term' ty -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall ty. Show ty => Int -> Term' ty -> ShowS
showsPrec :: Int -> Term' ty -> ShowS
$cshow :: forall ty. Show ty => Term' ty -> String
show :: Term' ty -> String
$cshowList :: forall ty. Show ty => [Term' ty] -> ShowS
showList :: [Term' ty] -> ShowS
Show
    , (forall a b. (a -> b) -> Term' a -> Term' b)
-> (forall a b. a -> Term' b -> Term' a) -> Functor Term'
forall a b. a -> Term' b -> Term' a
forall a b. (a -> b) -> Term' a -> Term' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Term' a -> Term' b
fmap :: forall a b. (a -> b) -> Term' a -> Term' b
$c<$ :: forall a b. a -> Term' b -> Term' a
<$ :: forall a b. a -> Term' b -> Term' a
Functor
    , (forall m. Monoid m => Term' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Term' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Term' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Term' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Term' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Term' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Term' a -> b)
-> (forall a. (a -> a -> a) -> Term' a -> a)
-> (forall a. (a -> a -> a) -> Term' a -> a)
-> (forall a. Term' a -> [a])
-> (forall a. Term' a -> Bool)
-> (forall a. Term' a -> Int)
-> (forall a. Eq a => a -> Term' a -> Bool)
-> (forall a. Ord a => Term' a -> a)
-> (forall a. Ord a => Term' a -> a)
-> (forall a. Num a => Term' a -> a)
-> (forall a. Num a => Term' a -> a)
-> Foldable Term'
forall a. Eq a => a -> Term' a -> Bool
forall a. Num a => Term' a -> a
forall a. Ord a => Term' a -> a
forall m. Monoid m => Term' m -> m
forall a. Term' a -> Bool
forall a. Term' a -> Int
forall a. Term' a -> [a]
forall a. (a -> a -> a) -> Term' a -> a
forall m a. Monoid m => (a -> m) -> Term' a -> m
forall b a. (b -> a -> b) -> b -> Term' a -> b
forall a b. (a -> b -> b) -> b -> Term' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Term' m -> m
fold :: forall m. Monoid m => Term' m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Term' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Term' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Term' a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Term' a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Term' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Term' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Term' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Term' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Term' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Term' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Term' a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Term' a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Term' a -> a
foldr1 :: forall a. (a -> a -> a) -> Term' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Term' a -> a
foldl1 :: forall a. (a -> a -> a) -> Term' a -> a
$ctoList :: forall a. Term' a -> [a]
toList :: forall a. Term' a -> [a]
$cnull :: forall a. Term' a -> Bool
null :: forall a. Term' a -> Bool
$clength :: forall a. Term' a -> Int
length :: forall a. Term' a -> Int
$celem :: forall a. Eq a => a -> Term' a -> Bool
elem :: forall a. Eq a => a -> Term' a -> Bool
$cmaximum :: forall a. Ord a => Term' a -> a
maximum :: forall a. Ord a => Term' a -> a
$cminimum :: forall a. Ord a => Term' a -> a
minimum :: forall a. Ord a => Term' a -> a
$csum :: forall a. Num a => Term' a -> a
sum :: forall a. Num a => Term' a -> a
$cproduct :: forall a. Num a => Term' a -> a
product :: forall a. Num a => Term' a -> a
Foldable
    , Typeable (Term' ty)
Typeable (Term' ty) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Term' ty -> c (Term' ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Term' ty))
-> (Term' ty -> Constr)
-> (Term' ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Term' ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Term' ty)))
-> ((forall b. Data b => b -> b) -> Term' ty -> Term' ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Term' ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Term' ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Term' ty -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Term' ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty))
-> Data (Term' ty)
Term' ty -> Constr
Term' ty -> DataType
(forall b. Data b => b -> b) -> Term' ty -> Term' ty
forall ty. Data ty => Typeable (Term' ty)
forall ty. Data ty => Term' ty -> Constr
forall ty. Data ty => Term' ty -> DataType
forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Term' ty -> Term' ty
forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Term' ty -> u
forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Term' ty -> [u]
forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' ty)
forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' ty -> c (Term' ty)
forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' ty))
forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' ty))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Term' ty -> u
forall u. (forall d. Data d => d -> u) -> Term' ty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' ty -> c (Term' ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' ty))
$cgfoldl :: forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' ty -> c (Term' ty)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' ty -> c (Term' ty)
$cgunfold :: forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' ty)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' ty)
$ctoConstr :: forall ty. Data ty => Term' ty -> Constr
toConstr :: Term' ty -> Constr
$cdataTypeOf :: forall ty. Data ty => Term' ty -> DataType
dataTypeOf :: Term' ty -> DataType
$cdataCast1 :: forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' ty))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' ty))
$cdataCast2 :: forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' ty))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' ty))
$cgmapT :: forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Term' ty -> Term' ty
gmapT :: (forall b. Data b => b -> b) -> Term' ty -> Term' ty
$cgmapQl :: forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
$cgmapQr :: forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' ty -> r
$cgmapQ :: forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Term' ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Term' ty -> [u]
$cgmapQi :: forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Term' ty -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Term' ty -> u
$cgmapM :: forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
$cgmapMp :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
$cgmapMo :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)
Data
    , (forall x. Term' ty -> Rep (Term' ty) x)
-> (forall x. Rep (Term' ty) x -> Term' ty) -> Generic (Term' ty)
forall x. Rep (Term' ty) x -> Term' ty
forall x. Term' ty -> Rep (Term' ty) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ty x. Rep (Term' ty) x -> Term' ty
forall ty x. Term' ty -> Rep (Term' ty) x
$cfrom :: forall ty x. Term' ty -> Rep (Term' ty) x
from :: forall x. Term' ty -> Rep (Term' ty) x
$cto :: forall ty x. Rep (Term' ty) x -> Term' ty
to :: forall x. Rep (Term' ty) x -> Term' ty
Generic
    , Eq (Term' ty)
Eq (Term' ty) =>
(Int -> Term' ty -> Int)
-> (Term' ty -> Int) -> Hashable (Term' ty)
Int -> Term' ty -> Int
Term' ty -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ty. Hashable ty => Eq (Term' ty)
forall ty. Hashable ty => Int -> Term' ty -> Int
forall ty. Hashable ty => Term' ty -> Int
$chashWithSalt :: forall ty. Hashable ty => Int -> Term' ty -> Int
hashWithSalt :: Int -> Term' ty -> Int
$chash :: forall ty. Hashable ty => Term' ty -> Int
hash :: Term' ty -> Int
Hashable
    , -- | The Traversable instance for Term (and for Syntax') is used during
      -- typechecking: during intermediate type inference, many of the type
      -- annotations placed on AST nodes will have unification variables in
      -- them. Once we have finished solving everything we need to do a
      -- final traversal over all the types in the AST to substitute away
      -- all the unification variables (and generalize, i.e. stick 'forall'
      -- on, as appropriate).  See the call to 'mapM' in
      -- Swarm.Language.Typecheck.runInfer.
      Functor Term'
Foldable Term'
(Functor Term', Foldable Term') =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Term' a -> f (Term' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Term' (f a) -> f (Term' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Term' a -> m (Term' b))
-> (forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a))
-> Traversable Term'
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
$csequence :: forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
sequence :: forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
Traversable
    )

instance Data ty => Plated (Term' ty) where
  plate :: Traversal' (Term' ty) (Term' ty)
plate = (Term' ty -> f (Term' ty)) -> Term' ty -> f (Term' ty)
forall a. Data a => Traversal' a a
Traversal' (Term' ty) (Term' ty)
uniplate