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

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

import Control.Lens (Plated (..))
import Data.Aeson.Types hiding (Key)
import Data.Data (Data)
import Data.Data.Lens (uniplate)
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.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)

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 appropriatly.
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, [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)

-- | 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
  | -- | 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.
    TRequireDevice Text
  | -- | Require a certain number of an entity.
    TRequire 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 Requirements@ field is 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 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 LocVar 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) Polytype
  | -- | Run the given command, then suspend and wait for a new REPL
    --   input.
    SSuspend (Syntax' ty)
  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
    , -- | 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

------------------------------------------------------------
-- Basic terms
------------------------------------------------------------

-- | Different runtime behaviors for delayed expressions.
data DelayType
  = -- | A simple delay, implemented via a (non-memoized) @VDelay@
    --   holding the delayed expression.
    SimpleDelay
  | -- | A memoized delay, implemented by allocating a mutable cell
    --   with the delayed expression and returning a reference to it.
    --   When the @Maybe Var@ is @Just@, a recursive binding of the
    --   variable with a reference to the delayed expression will be
    --   provided while evaluating the delayed expression itself. Note
    --   that there is no surface syntax for binding a variable within
    --   a recursive delayed expression; the only way we can get
    --   @Just@ here is when we automatically generate a delayed
    --   expression while interpreting a recursive @let@ or @def@.
    MemoizedDelay (Maybe Var)
  deriving (DelayType -> DelayType -> Bool
(DelayType -> DelayType -> Bool)
-> (DelayType -> DelayType -> Bool) -> Eq DelayType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelayType -> DelayType -> Bool
== :: DelayType -> DelayType -> Bool
$c/= :: DelayType -> DelayType -> Bool
/= :: DelayType -> DelayType -> Bool
Eq, Int -> DelayType -> ShowS
[DelayType] -> ShowS
DelayType -> String
(Int -> DelayType -> ShowS)
-> (DelayType -> String)
-> ([DelayType] -> ShowS)
-> Show DelayType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DelayType -> ShowS
showsPrec :: Int -> DelayType -> ShowS
$cshow :: DelayType -> String
show :: DelayType -> String
$cshowList :: [DelayType] -> ShowS
showList :: [DelayType] -> ShowS
Show, Typeable DelayType
Typeable DelayType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DelayType -> c DelayType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DelayType)
-> (DelayType -> Constr)
-> (DelayType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DelayType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DelayType))
-> ((forall b. Data b => b -> b) -> DelayType -> DelayType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DelayType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DelayType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DelayType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DelayType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DelayType -> m DelayType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DelayType -> m DelayType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DelayType -> m DelayType)
-> Data DelayType
DelayType -> Constr
DelayType -> DataType
(forall b. Data b => b -> b) -> DelayType -> DelayType
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) -> DelayType -> u
forall u. (forall d. Data d => d -> u) -> DelayType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DelayType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DelayType -> c DelayType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DelayType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DelayType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DelayType -> c DelayType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DelayType -> c DelayType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DelayType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DelayType
$ctoConstr :: DelayType -> Constr
toConstr :: DelayType -> Constr
$cdataTypeOf :: DelayType -> DataType
dataTypeOf :: DelayType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DelayType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DelayType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DelayType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DelayType)
$cgmapT :: (forall b. Data b => b -> b) -> DelayType -> DelayType
gmapT :: (forall b. Data b => b -> b) -> DelayType -> DelayType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DelayType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DelayType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DelayType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DelayType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DelayType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DelayType -> m DelayType
Data, (forall x. DelayType -> Rep DelayType x)
-> (forall x. Rep DelayType x -> DelayType) -> Generic DelayType
forall x. Rep DelayType x -> DelayType
forall x. DelayType -> Rep DelayType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DelayType -> Rep DelayType x
from :: forall x. DelayType -> Rep DelayType x
$cto :: forall x. Rep DelayType x -> DelayType
to :: forall x. Rep DelayType x -> DelayType
Generic, Maybe DelayType
Value -> Parser [DelayType]
Value -> Parser DelayType
(Value -> Parser DelayType)
-> (Value -> Parser [DelayType])
-> Maybe DelayType
-> FromJSON DelayType
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser DelayType
parseJSON :: Value -> Parser DelayType
$cparseJSONList :: Value -> Parser [DelayType]
parseJSONList :: Value -> Parser [DelayType]
$comittedField :: Maybe DelayType
omittedField :: Maybe DelayType
FromJSON, [DelayType] -> Value
[DelayType] -> Encoding
DelayType -> Bool
DelayType -> Value
DelayType -> Encoding
(DelayType -> Value)
-> (DelayType -> Encoding)
-> ([DelayType] -> Value)
-> ([DelayType] -> Encoding)
-> (DelayType -> Bool)
-> ToJSON DelayType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: DelayType -> Value
toJSON :: DelayType -> Value
$ctoEncoding :: DelayType -> Encoding
toEncoding :: DelayType -> Encoding
$ctoJSONList :: [DelayType] -> Value
toJSONList :: [DelayType] -> Value
$ctoEncodingList :: [DelayType] -> Encoding
toEncodingList :: [DelayType] -> Encoding
$comitField :: DelayType -> Bool
omitField :: DelayType -> Bool
ToJSON)