src/Language/PureScript/Declarations.hs · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on fd9dca2 help sign in

rowtype-yoga/purescript-native/src/Language/PureScript/Declarations.hs

387 lines 10 kB history raw

1-----------------------------------------------------------------------------

2--

3-- Module : Language.PureScript.Declarations

4-- Copyright : (c) Phil Freeman 2013

5-- License : MIT

6--

7-- Maintainer : Phil Freeman <paf31@cantab.net>

8-- Stability : experimental

9-- Portability :

10--

11-- | Data types for modules and declarations

12--

13-----------------------------------------------------------------------------

15{-# LANGUAGE DeriveDataTypeable #-}

17module Language.PureScript.Declarations where

19import Language.PureScript.Types

20import Language.PureScript.Names

21import Language.PureScript.Kinds

22import Language.PureScript.TypeClassDictionaries

23import Language.PureScript.CodeGen.JS.AST

24import Language.PureScript.Environment

26import qualified Data.Data as D

27import Data.Generics (mkQ, everything)

29-- |

30-- A precedence level for an infix operator

31--

32type Precedence = Integer

34-- |

35-- Associativity for infix operators

36--

37data Associativity = Infixl | Infixr | Infix deriving (D.Data, D.Typeable)

39instance Show Associativity where

40 show Infixl = "infixl"

41 show Infixr = "infixr"

42 show Infix = "infix"

44-- |

45-- Fixity data for infix operators

46--

47data Fixity = Fixity Associativity Precedence deriving (Show, D.Data, D.Typeable)

49-- |

50-- A module declaration, consisting of a module name, a list of declarations, and a list of the

51-- declarations that are explicitly imported. If the export list is Nothing, everything is exported.

52--

53data Module = Module ModuleName [Declaration] (Maybe [DeclarationRef]) deriving (Show, D.Data, D.Typeable)

55-- |

56-- An item in a list of explicit imports or exports

57--

58data DeclarationRef

59 -- |

60 -- A type constructor with data constructors

61 --

62 = TypeRef ProperName (Maybe [ProperName])

63 -- |

64 -- A value

65 --

66 | ValueRef Ident

67 -- |

68 -- A type class

69 --

70 | TypeClassRef ProperName

71 -- |

72 -- A type class instance, created during typeclass desugaring (name, class name, instance types)

73 --

74 | TypeInstanceRef Ident

75 deriving (Show, Eq, D.Data, D.Typeable)

77-- |

78-- The data type of declarations

79--

80data Declaration

81 -- |

82 -- A data type declaration (name, arguments, data constructors)

83 --

84 = DataDeclaration ProperName [String] [(ProperName, [Type])]

85 -- |

86 -- A minimal mutually recursive set of data type declarations

87 --

88 | DataBindingGroupDeclaration [Declaration]

89 -- |

90 -- A type synonym declaration (name, arguments, type)

91 --

92 | TypeSynonymDeclaration ProperName [String] Type

93 -- |

94 -- A type declaration for a value (name, ty)

95 --

96 | TypeDeclaration Ident Type

97 -- |

98 -- A value declaration (name, top-level binders, optional guard, value)

99 --

100 | ValueDeclaration Ident NameKind [Binder] (Maybe Guard) Value

101 -- |

102 -- A minimal mutually recursive set of value declarations

103 --

104 | BindingGroupDeclaration [(Ident, NameKind, Value)]

105 -- |

106 -- A foreign import declaration (type, name, optional inline Javascript, type)

107 --

108 | ExternDeclaration ForeignImportType Ident (Maybe JS) Type

109 -- |

110 -- A data type foreign import (name, kind)

111 --

112 | ExternDataDeclaration ProperName Kind

113 -- |

114 -- A type class instance foreign import

115 --

116 | ExternInstanceDeclaration Ident [(Qualified ProperName, [Type])] (Qualified ProperName) [Type]

117 -- |

118 -- A fixity declaration (fixity data, operator name)

119 --

120 | FixityDeclaration Fixity String

121 -- |

122 -- A module import (module name, optional set of identifiers to import, optional "qualified as"

123 -- name)

124 --

125 | ImportDeclaration ModuleName (Maybe [DeclarationRef]) (Maybe ModuleName)

126 -- |

127 -- A type class declaration (name, argument, member declarations)

128 --

129 | TypeClassDeclaration ProperName [String] [Declaration]

130 -- |

131 -- A type instance declaration (name, dependencies, class name, instance types, member

132 -- declarations)

133 --

134 | TypeInstanceDeclaration Ident [(Qualified ProperName, [Type])] (Qualified ProperName) [Type] [Declaration]

135 deriving (Show, D.Data, D.Typeable)

136

137-- |

138-- Test if a declaration is a value declaration

139--

140isValueDecl :: Declaration -> Bool

141isValueDecl ValueDeclaration{} = True

142isValueDecl _ = False

143

144-- |

145-- Test if a declaration is a data type or type synonym declaration

146--

147isDataDecl :: Declaration -> Bool

148isDataDecl DataDeclaration{} = True

149isDataDecl TypeSynonymDeclaration{} = True

150isDataDecl _ = False

151

152-- |

153-- Test if a declaration is a module import

154--

155isImportDecl :: Declaration -> Bool

156isImportDecl ImportDeclaration{} = True

157isImportDecl _ = False

158

159-- |

160-- Test if a declaration is a data type foreign import

161--

162isExternDataDecl :: Declaration -> Bool

163isExternDataDecl ExternDataDeclaration{} = True

164isExternDataDecl _ = False

165

166-- |

167-- Test if a declaration is a type class instance foreign import

168--

169isExternInstanceDecl :: Declaration -> Bool

170isExternInstanceDecl ExternInstanceDeclaration{} = True

171isExternInstanceDecl _ = False

172

173-- |

174-- Test if a declaration is a fixity declaration

175--

176isFixityDecl :: Declaration -> Bool

177isFixityDecl FixityDeclaration{} = True

178isFixityDecl _ = False

179

180-- |

181-- Test if a declaration is a foreign import

182--

183isExternDecl :: Declaration -> Bool

184isExternDecl ExternDeclaration{} = True

185isExternDecl _ = False

186

187-- |

188-- Test if a declaration is a type class or instance declaration

189--

190isTypeClassDeclaration :: Declaration -> Bool

191isTypeClassDeclaration TypeClassDeclaration{} = True

192isTypeClassDeclaration TypeInstanceDeclaration{} = True

193isTypeClassDeclaration _ = False

194

195-- |

196-- A guard is just a boolean-valued expression that appears alongside a set of binders

197--

198type Guard = Value

199

200-- |

201-- Data type for values

202--

203data Value

204 -- |

205 -- A numeric literal

206 --

207 = NumericLiteral (Either Integer Double)

208 -- |

209 -- A string literal

210 --

211 | StringLiteral String

212 -- |

213 -- A boolean literal

214 --

215 | BooleanLiteral Bool

216 -- |

217 -- A prefix -, will be desugared

218 --

219 | UnaryMinus Value

220 -- |

221 -- Binary operator application. During the rebracketing phase of desugaring, this data constructor

222 -- will be removed.

223 --

224 | BinaryNoParens (Qualified Ident) Value Value

225 -- |

226 -- Explicit parentheses. During the rebracketing phase of desugaring, this data constructor

227 -- will be removed.

228 --

229 | Parens Value

230 -- |

231 -- An array literal

232 --

233 | ArrayLiteral [Value]

234 -- |

235 -- An object literal

236 --

237 | ObjectLiteral [(String, Value)]

238 -- |

239 -- An record property accessor expression

240 --

241 | Accessor String Value

242 -- |

243 -- Partial record update

244 --

245 | ObjectUpdate Value [(String, Value)]

246 -- |

247 -- Function introduction

248 --

249 | Abs (Either Ident Binder) Value

250 -- |

251 -- Function application

252 --

253 | App Value Value

254 -- |

255 -- Variable

256 --

257 | Var (Qualified Ident)

258 -- |

259 -- Conditional (if-then-else expression)

260 --

261 | IfThenElse Value Value Value

262 -- |

263 -- A data constructor

264 --

265 | Constructor (Qualified ProperName)

266 -- |

267 -- A case expression. During the case expansion phase of desugaring, top-level binders will get

268 -- desugared into case expressions, hence the need for guards and multiple binders per branch here.

269 --

270 | Case [Value] [CaseAlternative]

271 -- |

272 -- A value with a type annotation

273 --

274 | TypedValue Bool Value Type

275 -- |

276 -- A let binding

277 --

278 | Let [Declaration] Value

279 -- |

280 -- A do-notation block

281 --

282 | Do [DoNotationElement]

283 -- |

284 -- A placeholder for a type class dictionary to be inserted later. At the end of type checking, these

285 -- placeholders will be replaced with actual expressions representing type classes dictionaries which

286 -- can be evaluated at runtime. The constructor arguments represent (in order): the type class name and

287 -- instance type, and the type class dictionaries in scope.

288 --

289 | TypeClassDictionary (Qualified ProperName, [Type]) [TypeClassDictionaryInScope] deriving (Show, D.Data, D.Typeable)

290

291-- |

292-- An alternative in a case statement

293--

294data CaseAlternative = CaseAlternative

295 { -- |

296 -- A collection of binders with which to match the inputs

297 --

298 caseAlternativeBinders :: [Binder]

299 -- |

300 -- An optional guard

301 --

302 , caseAlternativeGuard :: Maybe Guard

303 -- |

304 -- The result expression

305 --

306 , caseAlternativeResult :: Value

307 } deriving (Show, D.Data, D.Typeable)

308

309-- |

310-- Find the original dictionary which a type class dictionary in scope refers to

311--

312canonicalizeDictionary :: TypeClassDictionaryInScope -> Qualified Ident

313canonicalizeDictionary (TypeClassDictionaryInScope { tcdType = TCDRegular, tcdName = nm }) = nm

314canonicalizeDictionary (TypeClassDictionaryInScope { tcdType = TCDAlias nm }) = nm

315

316-- |

317-- A statement in a do-notation block

318--

319data DoNotationElement

320 -- |

321 -- A monadic value without a binder

322 --

323 = DoNotationValue Value

324 -- |

325 -- A monadic value with a binder

326 --

327 | DoNotationBind Binder Value

328 -- |

329 -- A let statement, i.e. a pure value with a binder

330 --

331 | DoNotationLet Binder Value deriving (Show, D.Data, D.Typeable)

332

333-- |

334-- Data type for binders

335--

336data Binder

337 -- |

338 -- Wildcard binder

339 --

340 = NullBinder

341 -- |

342 -- A binder which matches a boolean literal

343 --

344 | BooleanBinder Bool

345 -- |

346 -- A binder which matches a string literal

347 --

348 | StringBinder String

349 -- |

350 -- A binder which matches a numeric literal

351 --

352 | NumberBinder (Either Integer Double)

353 -- |

354 -- A binder which binds an identifier

355 --

356 | VarBinder Ident

357 -- |

358 -- A binder which matches a data constructor

359 --

360 | ConstructorBinder (Qualified ProperName) [Binder]

361 -- |

362 -- A binder which matches a record and binds its properties

363 --

364 | ObjectBinder [(String, Binder)]

365 -- |

366 -- A binder which matches an array and binds its elements

367 --

368 | ArrayBinder [Binder]

369 -- |

370 -- A binder which matches an array and binds its head and tail

371 --

372 | ConsBinder Binder Binder

373 -- |

374 -- A binder which binds its input to an identifier

375 --

376 | NamedBinder Ident Binder deriving (Show, D.Data, D.Typeable)

377

378

379-- |

380-- Collect all names introduced in binders in an expression

381--

382binderNames :: (D.Data d) => d -> [Ident]

383binderNames = everything (++) (mkQ [] go)

384 where

385 go (VarBinder ident) = [ident]

386 go (NamedBinder ident _) = [ident]

387 go _ = []